generate separate modules for gl, glu, glx; add info target

[clinton/guile-figl.git] / figl / low-level / gl.scm

;;; figl                           -*- mode: scheme; coding: utf-8 -*-
;;; Copyright (C) 2013 Andy Wingo <wingo@pobox.com>
;;;
;;; Figl is free software: you can redistribute it and/or modify it
;;; under the terms of the GNU Lesser General Public License as
;;; published by the Free Software Foundation, either version 3 of the
;;; License, or (at your option) any later version.
;;; 
;;; Figl is distributed in the hope that it will be useful, but WITHOUT
;;; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
;;; or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General
;;; Public License for more details.
;;; 
;;; You should have received a copy of the GNU Lesser General Public
;;; License along with this program.  If not, see
;;; <http://www.gnu.org/licenses/>.
;;;
;;; Derived from upstream OpenGL documentation.
;;; 
;;; Copyright
;;; =========
;;; 
;;; Copyright (C) 1991-2006 Silicon Graphics, Inc. This document is licensed
;;; under the SGI Free Software B License. For details, see
;;; http://oss.sgi.com/projects/FreeB/ (http://oss.sgi.com/projects/FreeB/).
;;; 
;;; Copyright
;;; =========
;;; 
;;; Copyright (C) 2003-2005 3Dlabs Inc. Ltd. This material may be
;;; distributed subject to the terms and conditions set forth in the Open
;;; Publication License, v 1.0, 8 June 1999. http://opencontent.org/openpub/
;;; (http://opencontent.org/openpub/).
;;; 
;;; Copyright
;;; =========
;;; 
;;; Copyright (C) 2005 Addison-Wesley. This material may be distributed
;;; subject to the terms and conditions set forth in the Open Publication
;;; License, v 1.0, 8 June 1999. http://opencontent.org/openpub/
;;; (http://opencontent.org/openpub/).
;;; 
;;; Copyright
;;; =========
;;; 
;;; Copyright (C) 2006 Khronos Group. This material may be distributed
;;; subject to the terms and conditions set forth in the Open Publication
;;; License, v 1.0, 8 June 1999. http://opencontent.org/openpub/
;;; (http://opencontent.org/openpub/).
;;;
;;; Automatically generated; you probably don't want to edit this.  To
;;; update, run "make update" in the top-level build tree.
;;;

(define-module
  (figl low-level gl)
  #:use-module
  (figl low-level support)
  #:export
  (glAccum
    glActiveTexture
    glAlphaFunc
    glAreTexturesResident
    glArrayElement
    glAttachShader
    glBeginQuery
    glBegin
    glBindAttribLocation
    glBindBuffer
    glBindTexture
    glBitmap
    glBlendColor
    glBlendEquationSeparate
    glBlendEquation
    glBlendFuncSeparate
    glBlendFunc
    glBufferData
    glBufferSubData
    glCallLists
    glCallList
    glClearAccum
    glClearColor
    glClearDepth
    glClearIndex
    glClearStencil
    glClear
    glClientActiveTexture
    glClipPlane
    glColorMask
    glColorMaterial
    glColorPointer
    glColorSubTable
    glColorTableParameter
    glColorTable
    glColor
    glCompileShader
    glCompressedTexImage1D
    glCompressedTexImage2D
    glCompressedTexImage3D
    glCompressedTexSubImage1D
    glCompressedTexSubImage2D
    glCompressedTexSubImage3D
    glConvolutionFilter1D
    glConvolutionFilter2D
    glConvolutionParameter
    glCopyColorSubTable
    glCopyColorTable
    glCopyConvolutionFilter1D
    glCopyConvolutionFilter2D
    glCopyPixels
    glCopyTexImage1D
    glCopyTexImage2D
    glCopyTexSubImage1D
    glCopyTexSubImage2D
    glCopyTexSubImage3D
    glCreateProgram
    glCreateShader
    glCullFace
    glDeleteBuffers
    glDeleteLists
    glDeleteProgram
    glDeleteQueries
    glDeleteShader
    glDeleteTextures
    glDepthFunc
    glDepthMask
    glDepthRange
    glDetachShader
    glDrawArrays
    glDrawBuffers
    glDrawBuffer
    glDrawElements
    glDrawPixels
    glDrawRangeElements
    glEdgeFlagPointer
    glEdgeFlag
    glEnableClientState
    glEnableVertexAttribArray
    glEnable
    glEvalCoord
    glEvalMesh
    glEvalPoint
    glFeedbackBuffer
    glFinish
    glFlush
    glFogCoordPointer
    glFogCoord
    glFog
    glFrontFace
    glFrustum
    glGenBuffers
    glGenLists
    glGenQueries
    glGenTextures
    glGetActiveAttrib
    glGetActiveUniform
    glGetAttachedShaders
    glGetAttribLocation
    glGetBufferParameteriv
    glGetBufferPointerv
    glGetBufferSubData
    glGetClipPlane
    glGetColorTableParameter
    glGetColorTable
    glGetCompressedTexImage
    glGetConvolutionFilter
    glGetConvolutionParameter
    glGetError
    glGetHistogramParameter
    glGetHistogram
    glGetLight
    glGetMap
    glGetMaterial
    glGetMinmaxParameter
    glGetMinmax
    glGetPixelMap
    glGetPointerv
    glGetPolygonStipple
    glGetProgramInfoLog
    glGetProgramiv
    glGetQueryiv
    glGetQueryObject
    glGetSeparableFilter
    glGetShaderInfoLog
    glGetShaderSource
    glGetShaderiv
    glGetString
    glGetTexEnv
    glGetTexGen
    glGetTexImage
    glGetTexLevelParameter
    glGetTexParameter
    glGetUniformLocation
    glGetUniformfv
    glGetVertexAttribPointerv
    glGetVertexAttribdv
    glGet
    glHint
    glHistogram
    glIndexMask
    glIndexPointer
    glIndex
    glInitNames
    glInterleavedArrays
    glIsBuffer
    glIsEnabled
    glIsList
    glIsProgram
    glIsQuery
    glIsShader
    glIsTexture
    glLightModel
    glLight
    glLineStipple
    glLineWidth
    glLinkProgram
    glListBase
    glLoadIdentity
    glLoadMatrix
    glLoadName
    glLoadTransposeMatrix
    glLogicOp
    glMap1
    glMap2
    glMapBuffer
    glMapGrid
    glMaterial
    glMatrixMode
    glMinmax
    glMultiDrawArrays
    glMultiDrawElements
    glMultiTexCoord
    glMultMatrix
    glMultTransposeMatrix
    glNewList
    glNormalPointer
    glNormal
    glOrtho
    glPassThrough
    glPixelMap
    glPixelStore
    glPixelTransfer
    glPixelZoom
    glPointParameter
    glPointSize
    glPolygonMode
    glPolygonOffset
    glPolygonStipple
    glPrioritizeTextures
    glPushAttrib
    glPushClientAttrib
    glPushMatrix
    glPushName
    glRasterPos
    glReadBuffer
    glReadPixels
    glRect
    glRenderMode
    glResetHistogram
    glResetMinmax
    glRotate
    glSampleCoverage
    glScale
    glScissor
    glSecondaryColorPointer
    glSecondaryColor
    glSelectBuffer
    glSeparableFilter2D
    glShadeModel
    glShaderSource
    glStencilFuncSeparate
    glStencilFunc
    glStencilMaskSeparate
    glStencilMask
    glStencilOpSeparate
    glStencilOp
    glTexCoordPointer
    glTexCoord
    glTexEnv
    glTexGen
    glTexImage1D
    glTexImage2D
    glTexImage3D
    glTexParameter
    glTexSubImage1D
    glTexSubImage2D
    glTexSubImage3D
    glTranslate
    glUniform1f
    glUseProgram
    glValidateProgram
    glVertexAttribPointer
    glVertexAttrib
    glVertexPointer
    glVertex
    glViewport
    glWindowPos))

(define-gl-procedure
  glAccum
  "glAccum"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glAccum"))
      (paramdef "GLenum " (parameter "op"))
      (paramdef "GLfloat " (parameter "value"))))
  '(*fragment*
     (heading "operate on the accumulation buffer")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "op")))
                   (para "
Specifies the accumulation buffer operation.
                    Symbolic constants "
                         (code "GL_ACCUM")
                         ", "
                         (code "GL_LOAD")
                         ", "
                         (code "GL_ADD")
                         ", "
                         (code "GL_MULT")
                         ",
                    and "
                         (code "GL_RETURN")
                         " are accepted. "))
            (entry (% (heading (var "value")))
                   (para "
Specifies a floating-point value used in the accumulation buffer operation. "
                         (var "op")
                         " determines how "
                         (var "value")
                         " is used. ")))
     (heading "Description")
     (para "
The accumulation buffer is an extended-range color buffer.
            Images are not rendered into it.
            Rather,
            images rendered into one of the color buffers
            are added to the contents of the accumulation buffer after rendering.
            Effects such as antialiasing (of points, lines, and polygons),
            motion blur,
            and depth of field can be created
            by accumulating images generated with different transformation matrices. ")
     (para "
Each pixel in the accumulation buffer consists of
            red, green, blue, and alpha values.
            The number of bits per component in the accumulation buffer
            depends on the implementation. You can examine this number
            by calling "
           (code "glGetIntegerv")
           " four times,
            with arguments "
           (code "GL_ACCUM_RED_BITS")
           ", "
           (code "GL_ACCUM_GREEN_BITS")
           ", "
           (code "GL_ACCUM_BLUE_BITS")
           ",
            and "
           (code "GL_ACCUM_ALPHA_BITS")
           ".
            Regardless of the number of bits per component,
            the range of values stored by each component is "
           (math "[" "-1" "," "1" "]")
           ".
            The accumulation buffer pixels are mapped one-to-one with frame buffer pixels. ")
     (para (code "glAccum")
           " operates on the accumulation buffer.
            The first argument, "
           (var "op")
           ",
            is a symbolic constant that selects an accumulation buffer operation.
            The second argument, "
           (var "value")
           ",
            is a floating-point value to be used in that operation.
            Five operations are specified: "
           (code "GL_ACCUM")
           ", "
           (code "GL_LOAD")
           ", "
           (code "GL_ADD")
           ", "
           (code "GL_MULT")
           ", and "
           (code "GL_RETURN")
           ". ")
     (para "
All accumulation buffer operations are limited
            to the area of the current scissor box and applied identically to
            the red, green, blue, and alpha components of each pixel.
            If a "
           (code "glAccum")
           " operation results in a value outside the range "
           (math "[" "-1" "," "1" "]")
           ",
            the contents of an accumulation buffer pixel component are undefined. ")
     (para "
The operations are as follows: ")
     (table (% (formatter (asis)))
            (entry (% (heading (code "GL_ACCUM")))
                   (para "
Obtains R, G, B, and A values
                        from the buffer currently selected for reading (see "
                         (code "glReadBuffer")
                         ").
                        Each component value is divided by "
                         (math "2" "^" (var "n") "-" "1")
                         ",
                        where "
                         (math (var "n"))
                         "
is the number of bits allocated to each color component
                        in the currently selected buffer.
                        The result is a floating-point value in the range "
                         (math "[" "0" "," "1" "]")
                         ",
                        which is multiplied by "
                         (var "value")
                         " and added to the corresponding pixel component
                        in the accumulation buffer,
                        thereby updating the accumulation buffer. "))
            (entry (% (heading (code "GL_LOAD")))
                   (para "
Similar to "
                         (code "GL_ACCUM")
                         ",
                        except that the current value in the accumulation buffer is not used
                        in the calculation of the new value.
                        That is, the R, G, B, and A values from the currently selected buffer
                        are divided by "
                         (math "2" "^" (var "n") "-" "1")
                         ",
                        multiplied by "
                         (var "value")
                         ",
                        and then stored in the corresponding accumulation buffer cell,
                        overwriting the current value. "))
            (entry (% (heading (code "GL_ADD")))
                   (para "
Adds "
                         (var "value")
                         " to each R, G, B, and A
                        in the accumulation buffer. "))
            (entry (% (heading (code "GL_MULT")))
                   (para "
Multiplies each R, G, B, and A
                        in the accumulation buffer by "
                         (var "value")
                         " and returns the scaled component
                        to its corresponding accumulation buffer location. "))
            (entry (% (heading (code "GL_RETURN")))
                   (para "
Transfers accumulation buffer values
                        to the color buffer or buffers currently selected for writing.
                        Each R, G, B, and A component is multiplied by "
                         (var "value")
                         ",
                        then multiplied by "
                         (math "2" "^" (var "n") "-" "1")
                         ",
                        clamped to the range "
                         (math "[" "0" "," "2" "^" (var "n") "-" "1" "]")
                         ",
                        and stored
                        in the corresponding display buffer cell.
                        The only fragment operations that are applied to this transfer are
                        pixel ownership,
                        scissor,
                        dithering,
                        and color writemasks. ")))
     (para "
To clear the accumulation buffer, call "
           (code "glClearAccum")
           " with R, G, B,
            and A values to set it to, then call "
           (code "glClear")
           " with the
            accumulation buffer enabled. ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "op")
           " is not an accepted value. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if there is no accumulation buffer. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glAccum")
           "
is executed between the execution of "
           (code "glBegin")
           " and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glActiveTexture
  "glActiveTexture"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glActiveTexture"))
      (paramdef "GLenum " (parameter "texture"))))
  '(*fragment*
     (heading "select active texture unit")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "texture")))
                   (para "
Specifies which texture unit to make active. The number
                    of texture units is implementation dependent, but must be at least
                    two. "
                         (var "texture")
                         " must be one of "
                         (code "GL_TEXTURE")
                         (math (var "i"))
                         ",
                    where
                    i ranges from 0 to the larger of ("
                         (code "GL_MAX_TEXTURE_COORDS")
                         " - 1)
                    and ("
                         (code "GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS")
                         " - 1). 
                    The initial value is "
                         (code "GL_TEXTURE0")
                         ". ")))
     (heading "Description")
     (para (code "glActiveTexture")
           " selects which texture unit subsequent texture state calls will
            affect.  The number of texture units an implementation supports is
            implementation dependent, but must be at least 2. ")
     (para "
Vertex arrays are client-side GL resources, which are selected by the "
           (code "glClientActiveTexture")
           " routine. ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "texture")
           " is not one of "
           (code "GL_TEXTURE")
           (math (var "i"))
           ",
            where i ranges from 0 to the larger of ("
           (code "GL_MAX_TEXTURE_COORDS")
           " - 1)
            and ("
           (code "GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS")
           " - 1). ")))

(define-gl-procedure
  glAlphaFunc
  "glAlphaFunc"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glAlphaFunc"))
      (paramdef "GLenum " (parameter "func"))
      (paramdef "GLclampf " (parameter "ref"))))
  '(*fragment*
     (heading "specify the alpha test function")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "func")))
                   (para "
Specifies the alpha comparison function.
                    Symbolic constants "
                         (code "GL_NEVER")
                         ", "
                         (code "GL_LESS")
                         ", "
                         (code "GL_EQUAL")
                         ", "
                         (code "GL_LEQUAL")
                         ", "
                         (code "GL_GREATER")
                         ", "
                         (code "GL_NOTEQUAL")
                         ", "
                         (code "GL_GEQUAL")
                         ", and "
                         (code "GL_ALWAYS")
                         " are accepted. The initial value is "
                         (code "GL_ALWAYS")
                         ". "))
            (entry (% (heading (var "ref")))
                   (para "
Specifies the reference value that incoming alpha values are compared to.
                    This value is clamped to the range "
                         (math "[" "0" "," "1" "]")
                         ",
                    where 0 represents the lowest possible alpha value
                    and 1 the highest possible value.
                    The initial reference value is 0. ")))
     (heading "Description")
     (para "
The alpha test discards fragments depending on the outcome of a comparison
            between an incoming fragment's alpha value and a constant reference value. "
           (code "glAlphaFunc")
           " specifies the reference value and the comparison function.
            The comparison is performed only if alpha testing is enabled. By
            default, it is not enabled.
            (See "
           (code "glEnable")
           " and "
           (code "glDisable")
           " of "
           (code "GL_ALPHA_TEST")
           ".) ")
     (para (var "func")
           " and "
           (var "ref")
           " specify the conditions under which
            the pixel is drawn.
            The incoming alpha value is compared to "
           (var "ref")
           "
using the function specified by "
           (var "func")
           ".
            If the value passes the comparison,
            the incoming fragment is drawn
            if it also passes subsequent stencil and depth buffer tests.
            If the value fails the comparison,
            no change is made to the frame buffer at that pixel location. The
            comparison functions are as follows: ")
     (table (% (formatter (asis)))
            (entry (% (heading (code "GL_NEVER")))
                   (para "
Never passes. "))
            (entry (% (heading (code "GL_LESS")))
                   (para "
Passes if the incoming alpha value is less than the reference value. "))
            (entry (% (heading (code "GL_EQUAL")))
                   (para "
Passes if the incoming alpha value is equal to the reference value. "))
            (entry (% (heading (code "GL_LEQUAL")))
                   (para "
Passes if the incoming alpha value is less than or equal to the reference value. "))
            (entry (% (heading (code "GL_GREATER")))
                   (para "
Passes if the incoming alpha value is greater than the reference value. "))
            (entry (% (heading (code "GL_NOTEQUAL")))
                   (para "
Passes if the incoming alpha value is not equal to the reference value. "))
            (entry (% (heading (code "GL_GEQUAL")))
                   (para "
Passes if the incoming alpha value is greater than or equal to
                        the reference value. "))
            (entry (% (heading (code "GL_ALWAYS")))
                   (para "
Always passes (initial value). ")))
     (para (code "glAlphaFunc")
           " operates on all pixel write operations,
            including those resulting from the scan conversion of points,
            lines,
            polygons,
            and bitmaps,
            and from pixel draw and copy operations. "
           (code "glAlphaFunc")
           " does not affect screen clear operations. ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "func")
           " is not an accepted value. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glAlphaFunc")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glAreTexturesResident
  "glAreTexturesResident"
  (funcsynopsis
    (funcprototype
      (funcdef
        "GLboolean "
        (function "glAreTexturesResident"))
      (paramdef "GLsizei " (parameter "n"))
      (paramdef
        "const GLuint * "
        (parameter "textures"))
      (paramdef
        "GLboolean * "
        (parameter "residences"))))
  '(*fragment*
     (heading
       "determine if textures are loaded in texture memory")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "n")))
                   (para "
Specifies the number of textures to be queried. "))
            (entry (% (heading (var "textures")))
                   (para "
Specifies an array containing the names of the textures to be queried. "))
            (entry (% (heading (var "residences")))
                   (para "
Specifies an array in which the texture residence status is returned.
                    The residence status of a texture named by an element of "
                         (var "textures")
                         " is
                    returned in the corresponding element of "
                         (var "residences")
                         ". ")))
     (heading "Description")
     (para "
GL establishes
            a ``working set'' of textures that are resident in texture memory.
            These textures can be bound to a texture target much more efficiently
            than textures that are not resident. ")
     (para (code "glAreTexturesResident")
           " queries the texture residence status of the "
           (var "n")
           " textures named by
            the elements of "
           (var "textures")
           ".
            If all the named textures are resident, "
           (code "glAreTexturesResident")
           " returns "
           (code "GL_TRUE")
           ",
            and the contents of "
           (var "residences")
           " are undisturbed.
            If not all the named textures are resident, "
           (code "glAreTexturesResident")
           " returns "
           (code "GL_FALSE")
           ",
            and detailed status is returned in the "
           (var "n")
           " elements of "
           (var "residences")
           ".
            If an element of "
           (var "residences")
           " is "
           (code "GL_TRUE")
           ", then the texture named by
            the corresponding element of "
           (var "textures")
           " is resident. ")
     (para "
The residence status of a single bound texture may also be queried
            by calling "
           (code "glGetTexParameter")
           " with the "
           (var "target")
           " argument set to the
            target to which the texture is bound, and the "
           (var "pname")
           " argument
            set to "
           (code "GL_TEXTURE_RESIDENT")
           ".
            This is the only way that the residence status of a default texture can be
            queried. ")
     (heading "Errors")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "n")
           " is negative. ")
     (para (code "GL_INVALID_VALUE")
           " is generated if any element in "
           (var "textures")
           "
is 0 or does not name a texture. In that case, the function returns "
           (code "GL_FALSE")
           " and the contents of "
           (var "residences")
           " is indeterminate. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glAreTexturesResident")
           " is executed
            between the execution of "
           (code "glBegin")
           " and the corresponding
            execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glArrayElement
  "glArrayElement"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glArrayElement"))
      (paramdef "GLint " (parameter "i"))))
  '(*fragment*
     (heading
       "render a vertex using the specified vertex array element")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "i")))
                   (para "
Specifies an index into the enabled vertex data arrays. ")))
     (heading "Description")
     (para (code "glArrayElement")
           " commands are used within "
           (code "glBegin")
           "/"
           (code "glEnd")
           " pairs to
            specify vertex and attribute data for point, line, and polygon
            primitives. If "
           (code "GL_VERTEX_ARRAY")
           " is enabled when "
           (code "glArrayElement")
           " is called, a
            single vertex is drawn, using
            vertex and attribute data taken from location "
           (var "i")
           " of the enabled
            arrays. If "
           (code "GL_VERTEX_ARRAY")
           " is not enabled, no drawing occurs but
            the attributes corresponding to the enabled arrays are modified. ")
     (para "
Use "
           (code "glArrayElement")
           " to construct primitives by indexing vertex data, rather than
            by streaming through arrays of data in first-to-last order. Because
            each call specifies only a single vertex, it is possible to explicitly
            specify per-primitive attributes such as a single normal for each
            triangle. ")
     (para "
Changes made to array data between the execution of "
           (code "glBegin")
           " and the
            corresponding execution of "
           (code "glEnd")
           " may affect calls to "
           (code "glArrayElement")
           " that are made
            within the same "
           (code "glBegin")
           "/"
           (code "glEnd")
           " period in nonsequential ways.
            That is, a call to "
           (code "glArrayElement")
           " that precedes a change to array data may
            access the changed data, and a call that follows a change to array data
            may access original data. ")
     (heading "Errors")
     (para (code "GL_INVALID_VALUE")
           " may be generated if "
           (var "i")
           " is negative. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to an
            enabled array and the buffer object's data store is currently mapped. ")))

(define-gl-procedure
  glAttachShader
  "glAttachShader"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glAttachShader"))
      (paramdef "GLuint " (parameter "program"))
      (paramdef "GLuint " (parameter "shader"))))
  '(*fragment*
     (heading
       "Attaches a shader object to a program object")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "program")))
                   (para "Specifies the program object to which a shader
\t\t    object will be attached."))
            (entry (% (heading (var "shader")))
                   (para "Specifies the shader object that is to be attached.")))
     (heading "Description")
     (para "In order to create an executable, there must be a way to
\tspecify the list of things that will be linked together. Program
\tobjects provide this mechanism. Shaders that are to be linked
\ttogether in a program object must first be attached to that
\tprogram object. "
           (code "glAttachShader")
           " attaches the
\tshader object specified by "
           (var "shader")
           " to the
\tprogram object specified by "
           (var "program")
           ". This
\tindicates that "
           (var "shader")
           " will be included in
\tlink operations that will be performed on\t"
           (var "program")
           ".")
     (para "All operations that can be performed on a shader object
\tare valid whether or not the shader object is attached to a
\tprogram object. It is permissible to attach a shader object to a
\tprogram object before source code has been loaded into the
\tshader object or before the shader object has been compiled. It
\tis permissible to attach multiple shader objects of the same
\ttype because each may contain a portion of the complete shader.
\tIt is also permissible to attach a shader object to more than
\tone program object. If a shader object is deleted while it is
\tattached to a program object, it will be flagged for deletion,
\tand deletion will not occur until\t"
           (code "glDetachShader")
           "
is called to detach it from all program objects to which it is
\tattached.")
     (heading "Errors")
     (para (code "GL_INVALID_VALUE")
           " is generated if either\t"
           (var "program")
           " or "
           (var "shader")
           "
is not a value generated by OpenGL.")
     (para (code "GL_INVALID_OPERATION")
           " is generated if\t"
           (var "program")
           " is not a program object.")
     (para (code "GL_INVALID_OPERATION")
           " is generated if\t"
           (var "shader")
           " is not a shader object.")
     (para (code "GL_INVALID_OPERATION")
           " is generated if\t"
           (var "shader")
           " is already attached to\t"
           (var "program")
           ".")
     (para (code "GL_INVALID_OPERATION")
           " is generated if\t"
           (code "glAttachShader")
           " is executed between the
\texecution of\t"
           (code "glBegin")
           "
and the corresponding execution of\t"
           (code "glEnd")
           ".")))

(define-gl-procedure
  glBeginQuery
  "glBeginQuery"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glBeginQuery"))
      (paramdef "GLenum " (parameter "target"))
      (paramdef "GLuint " (parameter "id"))))
  '(*fragment*
     (heading
       "delimit the boundaries of a query object")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "target")))
                   (para "
Specifies the target type of query object established between "
                         (code "glBeginQuery")
                         " and the subsequent "
                         (code "glEndQuery")
                         ".
                    The symbolic constant must be "
                         (code "GL_SAMPLES_PASSED")
                         ". "))
            (entry (% (heading (var "id")))
                   (para "
Specifies the name of a query object. ")))
     (heading "Description")
     (para (code "glBeginQuery")
           " and "
           (code "glEndQuery")
           " delimit the
            boundaries of a query object.  If a query object with name "
           (var "id")
           " does not yet exist it is created. ")
     (para "
When "
           (code "glBeginQuery")
           " is executed, the query object's samples-passed counter is reset to 0.  Subsequent
            rendering will increment the counter once for every sample that passes the depth test.  When "
           (code "glEndQuery")
           "
is executed, the samples-passed counter is assigned to the query object's result value.  This value can be queried by
            calling "
           (code "glGetQueryObject")
           " with "
           (var "pname")
           (code "GL_QUERY_RESULT")
           ". ")
     (para "
Querying the "
           (code "GL_QUERY_RESULT")
           " implicitly flushes the GL pipeline until the rendering delimited by the
            query object has completed and the result is available. "
           (code "GL_QUERY_RESULT_AVAILABLE")
           " can be queried to
            determine if the result is immediately available or if the rendering is not yet complete. ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "target")
           " is not "
           (code "GL_SAMPLES_PASSED")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glBeginQuery")
           " is executed while
            a query object of the same "
           (var "target")
           " is already active. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glEndQuery")
           "
is executed when a query object of the same "
           (var "target")
           " is not active. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (var "id")
           " is 0. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (var "id")
           " is the name of an already active query object. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glBeginQuery")
           " or "
           (code "glEndQuery")
           " is executed between the execution of "
           (code "glBegin")
           " and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glBegin
  "glBegin"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glBegin"))
      (paramdef "GLenum " (parameter "mode"))))
  '(*fragment*
     (heading
       "delimit the vertices of a primitive or a group of like primitives")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "mode")))
                   (para "
Specifies the primitive or primitives that will be created from vertices
                    presented between "
                         (code "glBegin")
                         " and the subsequent "
                         (code "glEnd")
                         ".
                    Ten symbolic constants are accepted: "
                         (code "GL_POINTS")
                         ", "
                         (code "GL_LINES")
                         ", "
                         (code "GL_LINE_STRIP")
                         ", "
                         (code "GL_LINE_LOOP")
                         ", "
                         (code "GL_TRIANGLES")
                         ", "
                         (code "GL_TRIANGLE_STRIP")
                         ", "
                         (code "GL_TRIANGLE_FAN")
                         ", "
                         (code "GL_QUADS")
                         ", "
                         (code "GL_QUAD_STRIP")
                         ", and "
                         (code "GL_POLYGON")
                         ". ")))
     (heading "Description")
     (para (code "glBegin")
           " and "
           (code "glEnd")
           " delimit the vertices that define a primitive or
            a group of like primitives. "
           (code "glBegin")
           " accepts a single argument that specifies in which of ten ways the
            vertices are interpreted.
            Taking "
           (math (var "n"))
           "
as an integer count starting at one,
            and "
           (math (var "N"))
           "
as the total number of vertices specified,
            the interpretations are as follows: ")
     (table (% (formatter (asis)))
            (entry (% (heading (code "GL_POINTS")))
                   (para "
Treats each vertex as a single point.
                        Vertex "
                         (math (var "n"))
                         "
defines point "
                         (math (var "n"))
                         ". "
                         (math (var "N"))
                         "
points are drawn. "))
            (entry (% (heading (code "GL_LINES")))
                   (para "
Treats each pair of vertices as an independent line segment.
                        Vertices "
                         (math "2" "\u2062" (var "n") "-" "1")
                         "
and "
                         (math "2" "\u2062" (var "n"))
                         "
define line "
                         (math (var "n"))
                         ". "
                         (math (var "N") "/" "2")
                         "
lines are drawn. "))
            (entry (% (heading (code "GL_LINE_STRIP")))
                   (para "
Draws a connected group of line segments from the first vertex
                        to the last.
                        Vertices "
                         (math (var "n"))
                         "
and "
                         (math (var "n") "+" "1")
                         "
define line "
                         (math (var "n"))
                         ". "
                         (math (var "N") "-" "1")
                         "
lines are drawn. "))
            (entry (% (heading (code "GL_LINE_LOOP")))
                   (para "
Draws a connected group of line segments from the first vertex
                        to the last,
                        then back to the first.
                        Vertices "
                         (math (var "n"))
                         "
and "
                         (math (var "n") "+" "1")
                         "
define line "
                         (math (var "n"))
                         ".
                        The last line, however, is defined by vertices "
                         (math (var "N"))
                         "
and "
                         (math "1")
                         ". "
                         (math (var "N"))
                         "
lines are drawn. "))
            (entry (% (heading (code "GL_TRIANGLES")))
                   (para "
Treats each triplet of vertices as an independent triangle.
                        Vertices "
                         (math "3" "\u2062" (var "n") "-" "2")
                         ", "
                         (math "3" "\u2062" (var "n") "-" "1")
                         ",
                        and "
                         (math "3" "\u2062" (var "n"))
                         "
define triangle "
                         (math (var "n"))
                         ". "
                         (math (var "N") "/" "3")
                         "
triangles are drawn. "))
            (entry (% (heading (code "GL_TRIANGLE_STRIP")))
                   (para "
Draws a connected group of triangles.  One triangle is defined for each
                        vertex presented after the first two vertices.  For odd "
                         (math (var "n"))
                         ",
                        vertices "
                         (math (var "n"))
                         ", "
                         (math (var "n") "+" "1")
                         ",
                        and "
                         (math (var "n") "+" "2")
                         "
define triangle "
                         (math (var "n"))
                         ".
                        For even "
                         (math (var "n"))
                         ",
                        vertices "
                         (math (var "n") "+" "1")
                         ", "
                         (math (var "n"))
                         ",
                        and "
                         (math (var "n") "+" "2")
                         "
define triangle "
                         (math (var "n"))
                         ". "
                         (math (var "N") "-" "2")
                         "
triangles are
                        drawn. "))
            (entry (% (heading (code "GL_TRIANGLE_FAN")))
                   (para "
Draws a connected group of triangles.
                        One triangle is defined for each vertex presented after the first two vertices.
                        Vertices "
                         (math "1")
                         ", "
                         (math (var "n") "+" "1")
                         ",
                        and "
                         (math (var "n") "+" "2")
                         "
define triangle "
                         (math (var "n"))
                         ". "
                         (math (var "N") "-" "2")
                         "
triangles are drawn. "))
            (entry (% (heading (code "GL_QUADS")))
                   (para "
Treats each group of four vertices as an independent quadrilateral.
                        Vertices "
                         (math "4" "\u2062" (var "n") "-" "3")
                         ", "
                         (math "4" "\u2062" (var "n") "-" "2")
                         ", "
                         (math "4" "\u2062" (var "n") "-" "1")
                         ",
                        and "
                         (math "4" "\u2062" (var "n"))
                         "
define quadrilateral "
                         (math (var "n"))
                         ". "
                         (math (var "N") "/" "4")
                         "
quadrilaterals are drawn. "))
            (entry (% (heading (code "GL_QUAD_STRIP")))
                   (para "
Draws a connected group of quadrilaterals.
                        One quadrilateral is defined for each pair of vertices presented
                        after the first pair.
                        Vertices "
                         (math "2" "\u2062" (var "n") "-" "1")
                         ", "
                         (math "2" "\u2062" (var "n"))
                         ", "
                         (math "2" "\u2062" (var "n") "+" "2")
                         ",
                        and "
                         (math "2" "\u2062" (var "n") "+" "1")
                         "
define quadrilateral "
                         (math (var "n"))
                         ". "
                         (math (var "N") "/" "2" "-" "1")
                         "
quadrilaterals are drawn.
                        Note that the order in which vertices are used to construct a quadrilateral
                        from strip data is different from that used with independent data. "))
            (entry (% (heading (code "GL_POLYGON")))
                   (para "
Draws a single,
                        convex polygon.
                        Vertices "
                         (math "1")
                         "
through "
                         (math (var "N"))
                         "
define this polygon. ")))
     (para "
Only a subset of GL commands can be used between "
           (code "glBegin")
           " and "
           (code "glEnd")
           ".
            The commands are "
           (code "glVertex")
           ", "
           (code "glColor")
           ", "
           (code "glSecondaryColor")
           ", "
           (code "glIndex")
           ", "
           (code "glNormal")
           ", "
           (code "glFogCoord")
           ", "
           (code "glTexCoord")
           ", "
           (code "glMultiTexCoord")
           ", "
           (code "glVertexAttrib")
           ", "
           (code "glEvalCoord")
           ", "
           (code "glEvalPoint")
           ", "
           (code "glArrayElement")
           ", "
           (code "glMaterial")
           ", and "
           (code "glEdgeFlag")
           ".
            Also,
            it is acceptable to use "
           (code "glCallList")
           " or "
           (code "glCallLists")
           " to execute
            display lists that include only the preceding commands.
            If any other GL command is executed between "
           (code "glBegin")
           " and "
           (code "glEnd")
           ",
            the error flag is set and the command is ignored. ")
     (para "
Regardless of the value chosen for "
           (var "mode")
           ",
            there is no limit to the number of vertices that can be defined
            between "
           (code "glBegin")
           " and "
           (code "glEnd")
           ".
            Lines,
            triangles,
            quadrilaterals,
            and polygons that are incompletely specified are not drawn.
            Incomplete specification results when either too few vertices are
            provided to specify even a single primitive or when an incorrect multiple
            of vertices is specified. The incomplete primitive is ignored; the rest are drawn. ")
     (para "
The minimum specification of vertices
            for each primitive is as follows:
            1 for a point,
            2 for a line,
            3 for a triangle,
            4 for a quadrilateral,
            and 3 for a polygon.
            Modes that require a certain multiple of vertices are "
           (code "GL_LINES")
           " (2), "
           (code "GL_TRIANGLES")
           " (3), "
           (code "GL_QUADS")
           " (4),
            and "
           (code "GL_QUAD_STRIP")
           " (2). ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "mode")
           " is set to an unaccepted value. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glBegin")
           " is executed between a "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glEnd")
           " is executed without being
            preceded by a "
           (code "glBegin")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a command other than "
           (code "glVertex")
           ", "
           (code "glColor")
           ", "
           (code "glSecondaryColor")
           ", "
           (code "glIndex")
           ", "
           (code "glNormal")
           ", "
           (code "glFogCoord")
           ", "
           (code "glTexCoord")
           ", "
           (code "glMultiTexCoord")
           ", "
           (code "glVertexAttrib")
           ", "
           (code "glEvalCoord")
           ", "
           (code "glEvalPoint")
           ", "
           (code "glArrayElement")
           ", "
           (code "glMaterial")
           ", "
           (code "glEdgeFlag")
           ", "
           (code "glCallList")
           ", or "
           (code "glCallLists")
           " is executed between
            the execution of "
           (code "glBegin")
           " and the corresponding
            execution "
           (code "glEnd")
           ". ")
     (para "
Execution of "
           (code "glEnableClientState")
           ", "
           (code "glDisableClientState")
           ", "
           (code "glEdgeFlagPointer")
           ", "
           (code "glFogCoordPointer")
           ", "
           (code "glTexCoordPointer")
           ", "
           (code "glColorPointer")
           ", "
           (code "glSecondaryColorPointer")
           ", "
           (code "glIndexPointer")
           ", "
           (code "glNormalPointer")
           ", "
           (code "glVertexPointer")
           ", "
           (code "glVertexAttribPointer")
           ", "
           (code "glInterleavedArrays")
           ", or "
           (code "glPixelStore")
           " is not allowed after a call to "
           (code "glBegin")
           " and before
            the corresponding call to "
           (code "glEnd")
           ",
            but an error may or may not be generated. ")))

(define-gl-procedure
  glBindAttribLocation
  "glBindAttribLocation"
  (funcsynopsis
    (funcprototype
      (funcdef
        "void "
        (function "glBindAttribLocation"))
      (paramdef "GLuint " (parameter "program"))
      (paramdef "GLuint " (parameter "index"))
      (paramdef "const GLchar *" (parameter "name"))))
  '(*fragment*
     (heading
       "Associates a generic vertex attribute index with a named attribute variable")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "program")))
                   (para "Specifies the handle of the program object in
\t\t    which the association is to be made."))
            (entry (% (heading (var "index")))
                   (para "Specifies the index of the generic vertex
\t\t    attribute to be bound."))
            (entry (% (heading (var "name")))
                   (para "Specifies a null terminated string containing
\t\t    the name of the vertex shader attribute variable to
\t\t    which "
                         (var "index")
                         " is to be
\t\t    bound.")))
     (heading "Description")
     (para (code "glBindAttribLocation")
           " is used to
\tassociate a user-defined attribute variable in the program
\tobject specified by "
           (var "program")
           " with a
\tgeneric vertex attribute index. The name of the user-defined
\tattribute variable is passed as a null terminated string in\t"
           (var "name")
           ". The generic vertex attribute index
\tto be bound to this variable is specified by\t"
           (var "index")
           ". When\t"
           (var "program")
           " is made part of current state,
\tvalues provided via the generic vertex attribute\t"
           (var "index")
           " will modify the value of the
\tuser-defined attribute variable specified by\t"
           (var "name")
           ".")
     (para "If "
           (var "name")
           " refers to a matrix
\tattribute variable, "
           (var "index")
           " refers to the
\tfirst column of the matrix. Other matrix columns are then
\tautomatically bound to locations "
           (var "index+1")
           "
for a matrix of type mat2; "
           (var "index+1")
           " and\t"
           (var "index+2")
           " for a matrix of type mat3; and\t"
           (var "index+1")
           ", "
           (var "index+2")
           ",
\tand "
           (var "index+3")
           " for a matrix of type
\tmat4.")
     (para "This command makes it possible for vertex shaders to use
\tdescriptive names for attribute variables rather than generic
\tvariables that are numbered from 0 to\t"
           (code "GL_MAX_VERTEX_ATTRIBS")
           " -1. The values sent
\tto each generic attribute index are part of current state, just
\tlike standard vertex attributes such as color, normal, and
\tvertex position. If a different program object is made current
\tby calling\t"
           (code "glUseProgram")
           ",
\tthe generic vertex attributes are tracked in such a way that the
\tsame values will be observed by attributes in the new program
\tobject that are also bound to\t"
           (var "index")
           ".")
     (para "Attribute variable
\tname-to-generic attribute index bindings for a program object
\tcan be explicitly assigned at any time by calling\t"
           (code "glBindAttribLocation")
           ". Attribute bindings do
\tnot go into effect until\t"
           (code "glLinkProgram")
           "
is called. After a program object has been linked successfully,
\tthe index values for generic attributes remain fixed (and their
\tvalues can be queried) until the next link command
\toccurs.")
     (para "Applications are not allowed to bind any of the standard
\tOpenGL vertex attributes using this command, as they are bound
\tautomatically when needed. Any attribute binding that occurs
\tafter the program object has been linked will not take effect
\tuntil the next time the program object is linked.")
     (heading "Errors")
     (para (code "GL_INVALID_VALUE")
           " is generated if\t"
           (var "index")
           " is greater than or equal to\t"
           (code "GL_MAX_VERTEX_ATTRIBS")
           ".")
     (para (code "GL_INVALID_OPERATION")
           " is generated if\t"
           (var "name")
           " starts with the reserved prefix
\t\"gl_\".")
     (para (code "GL_INVALID_VALUE")
           " is generated if\t"
           (var "program")
           " is not a value generated by
\tOpenGL.")
     (para (code "GL_INVALID_OPERATION")
           " is generated if\t"
           (var "program")
           " is not a program object.")
     (para (code "GL_INVALID_OPERATION")
           " is generated if\t"
           (code "glBindAttribLocation")
           " is executed between
\tthe execution of\t"
           (code "glBegin")
           "
and the corresponding execution of\t"
           (code "glEnd")
           ".")))

(define-gl-procedure
  glBindBuffer
  "glBindBuffer"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glBindBuffer"))
      (paramdef "GLenum " (parameter "target"))
      (paramdef "GLuint " (parameter "buffer"))))
  '(*fragment*
     (heading "bind a named buffer object")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "target")))
                   (para "
Specifies the target to which the buffer object is bound.
                    The symbolic constant must be "
                         (code "GL_ARRAY_BUFFER")
                         ", "
                         (code "GL_ELEMENT_ARRAY_BUFFER")
                         ", "
                         (code "GL_PIXEL_PACK_BUFFER")
                         ", or "
                         (code "GL_PIXEL_UNPACK_BUFFER")
                         ". "))
            (entry (% (heading (var "buffer")))
                   (para "
Specifies the name of a buffer object. ")))
     (heading "Description")
     (para (code "glBindBuffer")
           " lets you create or use a named buffer object. Calling "
           (code "glBindBuffer")
           " with "
           (var "target")
           " set to "
           (code "GL_ARRAY_BUFFER")
           ", "
           (code "GL_ELEMENT_ARRAY_BUFFER")
           ", "
           (code "GL_PIXEL_PACK_BUFFER")
           " or "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " and "
           (var "buffer")
           " set to the name
            of the new buffer object binds the buffer object name to the target.
            When a buffer object is bound to a target, the previous binding for that
            target is automatically broken. ")
     (para "
Buffer object names are unsigned integers. The value zero is reserved, but
            there is no default buffer object for each buffer object target. Instead, "
           (var "buffer")
           " set to zero
            effectively unbinds any buffer object previously bound, and restores client memory usage for that buffer object target.
            Buffer object names and the corresponding buffer object contents are local to
            the shared display-list space (see "
           (code "glXCreateContext")
           ") of the current
            GL rendering context;
            two rendering contexts share buffer object names only if they
            also share display lists. ")
     (para "
You may use "
           (code "glGenBuffers")
           " to generate a set of new buffer object names. ")
     (para "
The state of a buffer object immediately after it is first bound is an unmapped zero-sized memory buffer with "
           (code "GL_READ_WRITE")
           " access and "
           (code "GL_STATIC_DRAW")
           " usage. ")
     (para "
While a non-zero buffer object name is bound, GL operations on the target to which it is
            bound affect the bound buffer object, and queries of the target to which it is bound return state 
            from the bound buffer object. While buffer object name zero is bound, as in the initial state,
            attempts to modify or query state on the target to which it is bound generates an "
           (code "GL_INVALID_OPERATION")
           " error. ")
     (para "
When vertex array pointer state is changed, for example by a call to "
           (code "glNormalPointer")
           ", 
            the current buffer object binding ("
           (code "GL_ARRAY_BUFFER_BINDING")
           ") is copied into the 
            corresponding client state for the vertex array type being changed, for example "
           (code "GL_NORMAL_ARRAY_BUFFER_BINDING")
           ". While a non-zero buffer object is bound to the "
           (code "GL_ARRAY_BUFFER")
           " target, the vertex array pointer parameter that is traditionally
            interpreted as a pointer to client-side memory is instead interpreted as an offset within the
            buffer object measured in basic machine units. ")
     (para "
While a non-zero buffer object is bound to the "
           (code "GL_ELEMENT_ARRAY_BUFFER")
           " target, 
            the indices parameter of "
           (code "glDrawElements")
           ", "
           (code "glDrawRangeElements")
           ", or "
           (code "glMultiDrawElements")
           " that is traditionally
            interpreted as a pointer to client-side memory is instead interpreted as an offset within the
            buffer object measured in basic machine units. ")
     (para "
While a non-zero buffer object is bound to the "
           (code "GL_PIXEL_PACK_BUFFER")
           " target, 
            the following commands are affected: "
           (code "glGetCompressedTexImage")
           ", "
           (code "glGetConvolutionFilter")
           ", "
           (code "glGetHistogram")
           ", "
           (code "glGetMinmax")
           ", "
           (code "glGetPixelMap")
           ", "
           (code "glGetPolygonStipple")
           ", "
           (code "glGetSeparableFilter")
           ", "
           (code "glGetTexImage")
           ", and "
           (code "glReadPixels")
           ". The pointer parameter that is 
            traditionally interpreted as a pointer to client-side memory where the pixels are to be packed is instead 
            interpreted as an offset within the buffer object measured in basic machine units. ")
     (para "
While a non-zero buffer object is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target, 
            the following commands are affected: "
           (code "glBitmap")
           ", "
           (code "glColorSubTable")
           ", "
           (code "glColorTable")
           ", "
           (code "glCompressedTexImage1D")
           ", "
           (code "glCompressedTexImage2D")
           ", "
           (code "glCompressedTexImage3D")
           ", "
           (code "glCompressedTexSubImage1D")
           ", "
           (code "glCompressedTexSubImage2D")
           ", "
           (code "glCompressedTexSubImage3D")
           ", "
           (code "glConvolutionFilter1D")
           ", "
           (code "glConvolutionFilter2D")
           ", "
           (code "glDrawPixels")
           ", "
           (code "glPixelMap")
           ", "
           (code "glPolygonStipple")
           ", "
           (code "glSeparableFilter2D")
           ", "
           (code "glTexImage1D")
           ", "
           (code "glTexImage2D")
           ", "
           (code "glTexImage3D")
           ", "
           (code "glTexSubImage1D")
           ", "
           (code "glTexSubImage2D")
           ", and "
           (code "glTexSubImage3D")
           ". The pointer parameter that is 
            traditionally interpreted as a pointer to client-side memory from which the pixels are to be unpacked is 
            instead interpreted as an offset within the buffer object measured in basic machine units. ")
     (para "
A buffer object binding created with "
           (code "glBindBuffer")
           " remains active until a different
            buffer object name is bound to the same target, or until the bound buffer object is
            deleted with "
           (code "glDeleteBuffers")
           ". ")
     (para "
Once created, a named buffer object may be re-bound to any target as often as needed. However,
            the GL implementation may make choices about how to optimize the storage of a buffer object based
            on its initial binding target. ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "target")
           " is not one of the allowable
            values. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glBindBuffer")
           " is executed
            between the execution of "
           (code "glBegin")
           " and the corresponding
            execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glBindTexture
  "glBindTexture"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glBindTexture"))
      (paramdef "GLenum " (parameter "target"))
      (paramdef "GLuint " (parameter "texture"))))
  '(*fragment*
     (heading
       "bind a named texture to a texturing target")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "target")))
                   (para "
Specifies the target to which the texture is bound.
                    Must be either "
                         (code "GL_TEXTURE_1D")
                         ", "
                         (code "GL_TEXTURE_2D")
                         ", "
                         (code "GL_TEXTURE_3D")
                         ", or "
                         (code "GL_TEXTURE_CUBE_MAP")
                         ". "))
            (entry (% (heading (var "texture")))
                   (para "
Specifies the name of a texture. ")))
     (heading "Description")
     (para (code "glBindTexture")
           " lets you create or use a named texture. Calling "
           (code "glBindTexture")
           " with "
           (var "target")
           " set to "
           (code "GL_TEXTURE_1D")
           ", "
           (code "GL_TEXTURE_2D")
           ", "
           (code "GL_TEXTURE_3D")
           " or "
           (code "GL_TEXTURE_CUBE_MAP")
           " and "
           (var "texture")
           " set to the name
            of the new texture binds the texture name to the target.
            When a texture is bound to a target, the previous binding for that
            target is automatically broken. ")
     (para "
Texture names are unsigned integers. The value zero is reserved to
            represent the default texture for each texture target.
            Texture names and the corresponding texture contents are local to
            the shared display-list space (see "
           (code "glXCreateContext")
           ") of the current
            GL rendering context;
            two rendering contexts share texture names only if they
            also share display lists. ")
     (para "
You may use "
           (code "glGenTextures")
           " to generate a set of new texture names. ")
     (para "
When a texture is first bound, it assumes the specified target:
            A texture first bound to "
           (code "GL_TEXTURE_1D")
           " becomes one-dimensional texture, a
            texture first bound to "
           (code "GL_TEXTURE_2D")
           " becomes two-dimensional texture, a
            texture first bound to "
           (code "GL_TEXTURE_3D")
           " becomes three-dimensional texture, and a
            texture first bound to "
           (code "GL_TEXTURE_CUBE_MAP")
           "
becomes a cube-mapped texture. The state of a one-dimensional texture
            immediately after it is first bound is equivalent to the state of the
            default "
           (code "GL_TEXTURE_1D")
           " at GL initialization, and similarly for two-
            and three-dimensional textures and cube-mapped textures. ")
     (para "
While a texture is bound, GL operations on the target to which it is
            bound affect the bound texture, and queries of the target to which it
            is bound return state from the bound texture. If texture mapping is active
            on the target to which a texture is bound, the bound texture is used.
            In effect, the texture targets become aliases for the textures currently
            bound to them, and the texture name zero refers to the default textures
            that were bound to them at initialization. ")
     (para "
A texture binding created with "
           (code "glBindTexture")
           " remains active until a different
            texture is bound to the same target, or until the bound texture is
            deleted with "
           (code "glDeleteTextures")
           ". ")
     (para "
Once created, a named texture may be re-bound to its same original target as often as needed.
            It is usually much faster to use "
           (code "glBindTexture")
           " to bind an existing named
            texture to one of the texture targets than it is to reload the texture image
            using "
           (code "glTexImage1D")
           ", "
           (code "glTexImage2D")
           ", or "
           (code "glTexImage3D")
           ".
            For additional control over performance, use "
           (code "glPrioritizeTextures")
           ". ")
     (para (code "glBindTexture")
           " is included in display lists. ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "target")
           " is not one of the allowable
            values. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (var "texture")
           " was previously created with a target
            that doesn't match that of "
           (var "target")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glBindTexture")
           " is executed
            between the execution of "
           (code "glBegin")
           " and the corresponding
            execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glBitmap
  "glBitmap"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glBitmap"))
      (paramdef "GLsizei " (parameter "width"))
      (paramdef "GLsizei " (parameter "height"))
      (paramdef "GLfloat " (parameter "xorig"))
      (paramdef "GLfloat " (parameter "yorig"))
      (paramdef "GLfloat " (parameter "xmove"))
      (paramdef "GLfloat " (parameter "ymove"))
      (paramdef
        "const GLubyte * "
        (parameter "bitmap"))))
  '(*fragment*
     (heading "draw a bitmap")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "width")))
                   (itemx (var "height"))
                   (para "
Specify the pixel width and height of the bitmap image. "))
            (entry (% (heading (var "xorig")))
                   (itemx (var "yorig"))
                   (para "
Specify the location of the origin in the bitmap image.
                    The origin is measured from the lower left corner of the bitmap,
                    with right and up being the positive axes. "))
            (entry (% (heading (var "xmove")))
                   (itemx (var "ymove"))
                   (para "
Specify the "
                         (var "x")
                         " and "
                         (var "y")
                         " offsets to be added to the current raster position
                    after the bitmap is drawn. "))
            (entry (% (heading (var "bitmap")))
                   (para "
Specifies the address of the bitmap image. ")))
     (heading "Description")
     (para "
A bitmap is a binary image.
            When drawn,
            the bitmap is positioned relative to the current raster position,
            and frame buffer pixels corresponding to 1's in the bitmap are
            written using the current raster color or index.
            Frame buffer pixels corresponding to 0's in the bitmap are not modified. ")
     (para (code "glBitmap")
           " takes seven arguments.
            The first pair specifies the width and height of the bitmap image.
            The second pair specifies the location of the bitmap origin relative
            to the lower left corner of the bitmap image.
            The third pair of arguments specifies "
           (var "x")
           " and "
           (var "y")
           " offsets to be added
            to the current raster position after the bitmap has been drawn.
            The final argument is a pointer to the bitmap image itself. ")
     (para "
If a non-zero named buffer object is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target 
            (see "
           (code "glBindBuffer")
           ") while a bitmap image is
            specified, "
           (var "bitmap")
           " is treated as a byte offset into the buffer object's data store. ")
     (para "
The bitmap image is interpreted like image data for the "
           (code "glDrawPixels")
           "
command,
            with "
           (var "width")
           " and "
           (var "height")
           " corresponding to the width and height arguments
            of that command,
            and with "
           (var "type")
           " set to "
           (code "GL_BITMAP")
           "
and "
           (var "format")
           " set to "
           (code "GL_COLOR_INDEX")
           ".
            Modes specified using "
           (code "glPixelStore")
           " affect the
            interpretation of bitmap image data;
            modes specified using "
           (code "glPixelTransfer")
           " do not. ")
     (para "
If the current raster position is invalid, "
           (code "glBitmap")
           " is ignored.
            Otherwise,
            the lower left corner of the bitmap image is positioned at the window coordinates ")
     (para (math (var "x")
                 "_"
                 (var "w")
                 "="
                 "⌊"
                 (var "x")
                 "_"
                 (var "r")
                 "-"
                 (var "x")
                 "_"
                 (var "o")
                 ","
                 "⌋"))
     (para (math (var "y")
                 "_"
                 (var "w")
                 "="
                 "⌊"
                 (var "y")
                 "_"
                 (var "r")
                 "-"
                 (var "y")
                 "_"
                 (var "o")
                 ","
                 "⌋"))
     (para "
where "
           (math "("
                 (var "x")
                 "_"
                 (var "r")
                 ","
                 (var "y")
                 "_"
                 (var "r")
                 ")")
           "
is the raster position
            and "
           (math "("
                 (var "x")
                 "_"
                 (var "o")
                 ","
                 (var "y")
                 "_"
                 (var "o")
                 ")")
           "
is the bitmap origin.
            Fragments are then generated for each pixel corresponding to a 1 (one)
            in the bitmap image.
            These fragments are generated using the current raster "
           (var "z")
           " coordinate,
            color or color index, and current raster texture coordinates.
            They are then treated just as if they had been generated
            by a point, line, or polygon,
            including texture mapping,
            fogging,
            and all per-fragment operations such as alpha and depth testing. ")
     (para "
After the bitmap has been drawn,
            the "
           (var "x")
           " and "
           (var "y")
           " coordinates of the current raster position are offset by "
           (var "xmove")
           " and "
           (var "ymove")
           ".
            No change is made to the "
           (var "z")
           " coordinate of the current raster position,
            or to the current raster color, texture coordinates, or index. ")
     (heading "Errors")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "width")
           " or "
           (var "height")
           " is negative. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target and the buffer object's data store is currently mapped. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target and the data would be unpacked from the buffer 
            object such that the memory reads required would exceed the data store size. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glBitmap")
           "
is executed between the execution of "
           (code "glBegin")
           " and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glBlendColor
  "glBlendColor"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glBlendColor"))
      (paramdef "GLclampf " (parameter "red"))
      (paramdef "GLclampf " (parameter "green"))
      (paramdef "GLclampf " (parameter "blue"))
      (paramdef "GLclampf " (parameter "alpha"))))
  '(*fragment*
     (heading "set the blend color")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "red")))
                   (itemx (var "green"))
                   (itemx (var "blue"))
                   (itemx (var "alpha"))
                   (para "
specify the components of "
                         (code "GL_BLEND_COLOR"))))
     (heading "Description")
     (para "
The "
           (code "GL_BLEND_COLOR")
           " may be used to calculate the source and destination
            blending factors. The color components are clamped to the range "
           (math "[" "0" "," "1" "]")
           "
before being stored. See "
           (code "glBlendFunc")
           " for a complete description of the
            blending operations.
            Initially the "
           (code "GL_BLEND_COLOR")
           " is set to (0, 0, 0, 0). ")
     (heading "Errors")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glBlendColor")
           " is executed
            between the execution of "
           (code "glBegin")
           " and the corresponding
            execution of "
           (code "glEnd")
           ". ")
     (para)))

(define-gl-procedure
  glBlendEquationSeparate
  "glBlendEquationSeparate"
  (funcsynopsis
    (funcprototype
      (funcdef
        "void "
        (function "glBlendEquationSeparate"))
      (paramdef "GLenum " (parameter "modeRGB"))
      (paramdef "GLenum " (parameter "modeAlpha"))))
  '(*fragment*
     (heading
       "set the RGB blend equation and the alpha blend equation separately")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "modeRGB")))
                   (para "
specifies the RGB blend equation, how the red, green, and blue components of the source and destination colors are combined.
                    It must be "
                         (code "GL_FUNC_ADD")
                         ", "
                         (code "GL_FUNC_SUBTRACT")
                         ", "
                         (code "GL_FUNC_REVERSE_SUBTRACT")
                         ", "
                         (code "GL_MIN")
                         ", "
                         (code "GL_MAX")
                         ". "))
            (entry (% (heading (var "modeAlpha")))
                   (para "
specifies the alpha blend equation, how the alpha component of the source and destination colors are combined.
                    It must be "
                         (code "GL_FUNC_ADD")
                         ", "
                         (code "GL_FUNC_SUBTRACT")
                         ", "
                         (code "GL_FUNC_REVERSE_SUBTRACT")
                         ", "
                         (code "GL_MIN")
                         ", "
                         (code "GL_MAX")
                         ". ")))
     (heading "Description")
     (para "
The blend equations determines how a new pixel (the ''source'' color)
            is combined with a pixel already in the framebuffer (the ''destination''
            color).  This function specifies one blend equation for the RGB-color 
            components and one blend equation for the alpha component. ")
     (para "
The blend equations use the source and destination blend factors
            specified by either "
           (code "glBlendFunc")
           " or "
           (code "glBlendFuncSeparate")
           ".
            See "
           (code "glBlendFunc")
           " or "
           (code "glBlendFuncSeparate")
           "
for a description of the various blend factors. ")
     (para "
In the equations that follow, source and destination
            color components are referred to as "
           (math "("
                 (var "R")
                 "_"
                 (var "s")
                 ","
                 (var "G")
                 "_"
                 (var "s")
                 (var "B")
                 "_"
                 (var "s")
                 (var "A")
                 "_"
                 (var "s")
                 ")")
           "
and "
           (math "("
                 (var "R")
                 "_"
                 (var "d")
                 ","
                 (var "G")
                 "_"
                 (var "d")
                 (var "B")
                 "_"
                 (var "d")
                 (var "A")
                 "_"
                 (var "d")
                 ")")
           ",
            respectively.
            The result color is referred to as "
           (math "("
                 (var "R")
                 "_"
                 (var "r")
                 ","
                 (var "G")
                 "_"
                 (var "r")
                 (var "B")
                 "_"
                 (var "r")
                 (var "A")
                 "_"
                 (var "r")
                 ")")
           ".
            The source and destination blend factors are denoted "
           (math "("
                 (var "s")
                 "_"
                 (var "R")
                 ","
                 (var "s")
                 "_"
                 (var "G")
                 (var "s")
                 "_"
                 (var "B")
                 (var "s")
                 "_"
                 (var "A")
                 ")")
           "
and "
           (math "("
                 (var "d")
                 "_"
                 (var "R")
                 ","
                 (var "d")
                 "_"
                 (var "G")
                 (var "d")
                 "_"
                 (var "B")
                 (var "d")
                 "_"
                 (var "A")
                 ")")
           ",
            respectively.
            For these equations all color components are understood to have values
            in the range "
           (math "[" "0" "," "1" "]")
           ". ")
     (table (% (formatter (asis)))
            (entry (% (heading (strong "Mode")))
                   (para (strong "RGB Components")
                         ", "
                         (strong "Alpha Component")))
            (entry (% (heading (code "GL_FUNC_ADD")))
                   (para (math (var "Rr")
                               "="
                               (var "R")
                               "_"
                               (var "s")
                               "\u2062"
                               (var "s")
                               "_"
                               (var "R")
                               "+"
                               (var "R")
                               "_"
                               (var "d")
                               "\u2062"
                               (var "d")
                               "_"
                               (var "R"))
                         (math (var "Gr")
                               "="
                               (var "G")
                               "_"
                               (var "s")
                               "\u2062"
                               (var "s")
                               "_"
                               (var "G")
                               "+"
                               (var "G")
                               "_"
                               (var "d")
                               "\u2062"
                               (var "d")
                               "_"
                               (var "G"))
                         (math (var "Br")
                               "="
                               (var "B")
                               "_"
                               (var "s")
                               "\u2062"
                               (var "s")
                               "_"
                               (var "B")
                               "+"
                               (var "B")
                               "_"
                               (var "d")
                               "\u2062"
                               (var "d")
                               "_"
                               (var "B"))
                         ", "
                         (math (var "Ar")
                               "="
                               (var "A")
                               "_"
                               (var "s")
                               "\u2062"
                               (var "s")
                               "_"
                               (var "A")
                               "+"
                               (var "A")
                               "_"
                               (var "d")
                               "\u2062"
                               (var "d")
                               "_"
                               (var "A"))))
            (entry (% (heading (code "GL_FUNC_SUBTRACT")))
                   (para (math (var "Rr")
                               "="
                               (var "R")
                               "_"
                               (var "s")
                               "\u2062"
                               (var "s")
                               "_"
                               (var "R")
                               "-"
                               (var "R")
                               "_"
                               (var "d")
                               "\u2062"
                               (var "d")
                               "_"
                               (var "R"))
                         (math (var "Gr")
                               "="
                               (var "G")
                               "_"
                               (var "s")
                               "\u2062"
                               (var "s")
                               "_"
                               (var "G")
                               "-"
                               (var "G")
                               "_"
                               (var "d")
                               "\u2062"
                               (var "d")
                               "_"
                               (var "G"))
                         (math (var "Br")
                               "="
                               (var "B")
                               "_"
                               (var "s")
                               "\u2062"
                               (var "s")
                               "_"
                               (var "B")
                               "-"
                               (var "B")
                               "_"
                               (var "d")
                               "\u2062"
                               (var "d")
                               "_"
                               (var "B"))
                         ", "
                         (math (var "Ar")
                               "="
                               (var "A")
                               "_"
                               (var "s")
                               "\u2062"
                               (var "s")
                               "_"
                               (var "A")
                               "-"
                               (var "A")
                               "_"
                               (var "d")
                               "\u2062"
                               (var "d")
                               "_"
                               (var "A"))))
            (entry (% (heading (code "GL_FUNC_REVERSE_SUBTRACT")))
                   (para (math (var "Rr")
                               "="
                               (var "R")
                               "_"
                               (var "d")
                               "\u2062"
                               (var "d")
                               "_"
                               (var "R")
                               "-"
                               (var "R")
                               "_"
                               (var "s")
                               "\u2062"
                               (var "s")
                               "_"
                               (var "R"))
                         (math (var "Gr")
                               "="
                               (var "G")
                               "_"
                               (var "d")
                               "\u2062"
                               (var "d")
                               "_"
                               (var "G")
                               "-"
                               (var "G")
                               "_"
                               (var "s")
                               "\u2062"
                               (var "s")
                               "_"
                               (var "G"))
                         (math (var "Br")
                               "="
                               (var "B")
                               "_"
                               (var "d")
                               "\u2062"
                               (var "d")
                               "_"
                               (var "B")
                               "-"
                               (var "B")
                               "_"
                               (var "s")
                               "\u2062"
                               (var "s")
                               "_"
                               (var "B"))
                         ", "
                         (math (var "Ar")
                               "="
                               (var "A")
                               "_"
                               (var "d")
                               "\u2062"
                               (var "d")
                               "_"
                               (var "A")
                               "-"
                               (var "A")
                               "_"
                               (var "s")
                               "\u2062"
                               (var "s")
                               "_"
                               (var "A"))))
            (entry (% (heading (code "GL_MIN")))
                   (para (math (var "Rr")
                               "="
                               (var "min")
                               "\u2061"
                               "("
                               (var "R")
                               "_"
                               (var "s")
                               ","
                               (var "R")
                               "_"
                               (var "d")
                               ")")
                         (math (var "Gr")
                               "="
                               (var "min")
                               "\u2061"
                               "("
                               (var "G")
                               "_"
                               (var "s")
                               ","
                               (var "G")
                               "_"
                               (var "d")
                               ")")
                         (math (var "Br")
                               "="
                               (var "min")
                               "\u2061"
                               "("
                               (var "B")
                               "_"
                               (var "s")
                               ","
                               (var "B")
                               "_"
                               (var "d")
                               ")")
                         ", "
                         (math (var "Ar")
                               "="
                               (var "min")
                               "\u2061"
                               "("
                               (var "A")
                               "_"
                               (var "s")
                               ","
                               (var "A")
                               "_"
                               (var "d")
                               ")")))
            (entry (% (heading (code "GL_MAX")))
                   (para (math (var "Rr")
                               "="
                               (var "max")
                               "\u2061"
                               "("
                               (var "R")
                               "_"
                               (var "s")
                               ","
                               (var "R")
                               "_"
                               (var "d")
                               ")")
                         (math (var "Gr")
                               "="
                               (var "max")
                               "\u2061"
                               "("
                               (var "G")
                               "_"
                               (var "s")
                               ","
                               (var "G")
                               "_"
                               (var "d")
                               ")")
                         (math (var "Br")
                               "="
                               (var "max")
                               "\u2061"
                               "("
                               (var "B")
                               "_"
                               (var "s")
                               ","
                               (var "B")
                               "_"
                               (var "d")
                               ")")
                         ", "
                         (math (var "Ar")
                               "="
                               (var "max")
                               "\u2061"
                               "("
                               (var "A")
                               "_"
                               (var "s")
                               ","
                               (var "A")
                               "_"
                               (var "d")
                               ")"))))
     (para "
The results of these equations are clamped to the range "
           (math "[" "0" "," "1" "]")
           ". ")
     (para "
The "
           (code "GL_MIN")
           " and "
           (code "GL_MAX")
           " equations are useful for applications
            that analyze image data (image thresholding against a constant color,
            for example).
            The "
           (code "GL_FUNC_ADD")
           " equation is useful
            for antialiasing and transparency, among other things. ")
     (para "
Initially, both the RGB blend equation and the alpha blend equation are set to "
           (code "GL_FUNC_ADD")
           ". ")
     (para)
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if either "
           (var "modeRGB")
           " or "
           (var "modeAlpha")
           " is not one of "
           (code "GL_FUNC_ADD")
           ", "
           (code "GL_FUNC_SUBTRACT")
           ", "
           (code "GL_FUNC_REVERSE_SUBTRACT")
           ", "
           (code "GL_MAX")
           ", or "
           (code "GL_MIN")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glBlendEquationSeparate")
           " is executed
            between the execution of "
           (code "glBegin")
           " and the corresponding
            execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glBlendEquation
  "glBlendEquation"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glBlendEquation"))
      (paramdef "GLenum " (parameter "mode"))))
  '(*fragment*
     (heading
       "specify the equation used for both the RGB blend equation and the Alpha blend equation")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "mode")))
                   (para "
specifies how source and destination colors are combined.
                    It must be "
                         (code "GL_FUNC_ADD")
                         ", "
                         (code "GL_FUNC_SUBTRACT")
                         ", "
                         (code "GL_FUNC_REVERSE_SUBTRACT")
                         ", "
                         (code "GL_MIN")
                         ", "
                         (code "GL_MAX")
                         ". ")))
     (heading "Description")
     (para "
The blend equations determine how a new pixel (the ''source'' color)
            is combined with a pixel already in the framebuffer (the ''destination''
            color).  This function sets both the RGB blend equation and the alpha 
            blend equation to a single equation. ")
     (para "
These equations use the source and destination blend factors
            specified by either "
           (code "glBlendFunc")
           " or "
           (code "glBlendFuncSeparate")
           ".
            See "
           (code "glBlendFunc")
           " or "
           (code "glBlendFuncSeparate")
           "
for a description of the various blend factors. ")
     (para "
In the equations that follow, source and destination
            color components are referred to as "
           (math "("
                 (var "R")
                 "_"
                 (var "s")
                 ","
                 (var "G")
                 "_"
                 (var "s")
                 (var "B")
                 "_"
                 (var "s")
                 (var "A")
                 "_"
                 (var "s")
                 ")")
           "
and "
           (math "("
                 (var "R")
                 "_"
                 (var "d")
                 ","
                 (var "G")
                 "_"
                 (var "d")
                 (var "B")
                 "_"
                 (var "d")
                 (var "A")
                 "_"
                 (var "d")
                 ")")
           ",
            respectively.
            The result color is referred to as "
           (math "("
                 (var "R")
                 "_"
                 (var "r")
                 ","
                 (var "G")
                 "_"
                 (var "r")
                 (var "B")
                 "_"
                 (var "r")
                 (var "A")
                 "_"
                 (var "r")
                 ")")
           ".
            The source and destination blend factors are denoted "
           (math "("
                 (var "s")
                 "_"
                 (var "R")
                 ","
                 (var "s")
                 "_"
                 (var "G")
                 (var "s")
                 "_"
                 (var "B")
                 (var "s")
                 "_"
                 (var "A")
                 ")")
           "
and "
           (math "("
                 (var "d")
                 "_"
                 (var "R")
                 ","
                 (var "d")
                 "_"
                 (var "G")
                 (var "d")
                 "_"
                 (var "B")
                 (var "d")
                 "_"
                 (var "A")
                 ")")
           ",
            respectively.
            For these equations all color components are understood to have values
            in the range "
           (math "[" "0" "," "1" "]")
           ". ")
     (table (% (formatter (asis)))
            (entry (% (heading (strong "Mode")))
                   (para (strong "RGB Components")
                         ", "
                         (strong "Alpha Component")))
            (entry (% (heading (code "GL_FUNC_ADD")))
                   (para (math (var "Rr")
                               "="
                               (var "R")
                               "_"
                               (var "s")
                               "\u2062"
                               (var "s")
                               "_"
                               (var "R")
                               "+"
                               (var "R")
                               "_"
                               (var "d")
                               "\u2062"
                               (var "d")
                               "_"
                               (var "R"))
                         (math (var "Gr")
                               "="
                               (var "G")
                               "_"
                               (var "s")
                               "\u2062"
                               (var "s")
                               "_"
                               (var "G")
                               "+"
                               (var "G")
                               "_"
                               (var "d")
                               "\u2062"
                               (var "d")
                               "_"
                               (var "G"))
                         (math (var "Br")
                               "="
                               (var "B")
                               "_"
                               (var "s")
                               "\u2062"
                               (var "s")
                               "_"
                               (var "B")
                               "+"
                               (var "B")
                               "_"
                               (var "d")
                               "\u2062"
                               (var "d")
                               "_"
                               (var "B"))
                         ", "
                         (math (var "Ar")
                               "="
                               (var "A")
                               "_"
                               (var "s")
                               "\u2062"
                               (var "s")
                               "_"
                               (var "A")
                               "+"
                               (var "A")
                               "_"
                               (var "d")
                               "\u2062"
                               (var "d")
                               "_"
                               (var "A"))))
            (entry (% (heading (code "GL_FUNC_SUBTRACT")))
                   (para (math (var "Rr")
                               "="
                               (var "R")
                               "_"
                               (var "s")
                               "\u2062"
                               (var "s")
                               "_"
                               (var "R")
                               "-"
                               (var "R")
                               "_"
                               (var "d")
                               "\u2062"
                               (var "d")
                               "_"
                               (var "R"))
                         (math (var "Gr")
                               "="
                               (var "G")
                               "_"
                               (var "s")
                               "\u2062"
                               (var "s")
                               "_"
                               (var "G")
                               "-"
                               (var "G")
                               "_"
                               (var "d")
                               "\u2062"
                               (var "d")
                               "_"
                               (var "G"))
                         (math (var "Br")
                               "="
                               (var "B")
                               "_"
                               (var "s")
                               "\u2062"
                               (var "s")
                               "_"
                               (var "B")
                               "-"
                               (var "B")
                               "_"
                               (var "d")
                               "\u2062"
                               (var "d")
                               "_"
                               (var "B"))
                         ", "
                         (math (var "Ar")
                               "="
                               (var "A")
                               "_"
                               (var "s")
                               "\u2062"
                               (var "s")
                               "_"
                               (var "A")
                               "-"
                               (var "A")
                               "_"
                               (var "d")
                               "\u2062"
                               (var "d")
                               "_"
                               (var "A"))))
            (entry (% (heading (code "GL_FUNC_REVERSE_SUBTRACT")))
                   (para (math (var "Rr")
                               "="
                               (var "R")
                               "_"
                               (var "d")
                               "\u2062"
                               (var "d")
                               "_"
                               (var "R")
                               "-"
                               (var "R")
                               "_"
                               (var "s")
                               "\u2062"
                               (var "s")
                               "_"
                               (var "R"))
                         (math (var "Gr")
                               "="
                               (var "G")
                               "_"
                               (var "d")
                               "\u2062"
                               (var "d")
                               "_"
                               (var "G")
                               "-"
                               (var "G")
                               "_"
                               (var "s")
                               "\u2062"
                               (var "s")
                               "_"
                               (var "G"))
                         (math (var "Br")
                               "="
                               (var "B")
                               "_"
                               (var "d")
                               "\u2062"
                               (var "d")
                               "_"
                               (var "B")
                               "-"
                               (var "B")
                               "_"
                               (var "s")
                               "\u2062"
                               (var "s")
                               "_"
                               (var "B"))
                         ", "
                         (math (var "Ar")
                               "="
                               (var "A")
                               "_"
                               (var "d")
                               "\u2062"
                               (var "d")
                               "_"
                               (var "A")
                               "-"
                               (var "A")
                               "_"
                               (var "s")
                               "\u2062"
                               (var "s")
                               "_"
                               (var "A"))))
            (entry (% (heading (code "GL_MIN")))
                   (para (math (var "Rr")
                               "="
                               (var "min")
                               "\u2061"
                               "("
                               (var "R")
                               "_"
                               (var "s")
                               ","
                               (var "R")
                               "_"
                               (var "d")
                               ")")
                         (math (var "Gr")
                               "="
                               (var "min")
                               "\u2061"
                               "("
                               (var "G")
                               "_"
                               (var "s")
                               ","
                               (var "G")
                               "_"
                               (var "d")
                               ")")
                         (math (var "Br")
                               "="
                               (var "min")
                               "\u2061"
                               "("
                               (var "B")
                               "_"
                               (var "s")
                               ","
                               (var "B")
                               "_"
                               (var "d")
                               ")")
                         ", "
                         (math (var "Ar")
                               "="
                               (var "min")
                               "\u2061"
                               "("
                               (var "A")
                               "_"
                               (var "s")
                               ","
                               (var "A")
                               "_"
                               (var "d")
                               ")")))
            (entry (% (heading (code "GL_MAX")))
                   (para (math (var "Rr")
                               "="
                               (var "max")
                               "\u2061"
                               "("
                               (var "R")
                               "_"
                               (var "s")
                               ","
                               (var "R")
                               "_"
                               (var "d")
                               ")")
                         (math (var "Gr")
                               "="
                               (var "max")
                               "\u2061"
                               "("
                               (var "G")
                               "_"
                               (var "s")
                               ","
                               (var "G")
                               "_"
                               (var "d")
                               ")")
                         (math (var "Br")
                               "="
                               (var "max")
                               "\u2061"
                               "("
                               (var "B")
                               "_"
                               (var "s")
                               ","
                               (var "B")
                               "_"
                               (var "d")
                               ")")
                         ", "
                         (math (var "Ar")
                               "="
                               (var "max")
                               "\u2061"
                               "("
                               (var "A")
                               "_"
                               (var "s")
                               ","
                               (var "A")
                               "_"
                               (var "d")
                               ")"))))
     (para "
The results of these equations are clamped to the range "
           (math "[" "0" "," "1" "]")
           ". ")
     (para "
The "
           (code "GL_MIN")
           " and "
           (code "GL_MAX")
           " equations are useful for applications
            that analyze image data (image thresholding against a constant color,
            for example).
            The "
           (code "GL_FUNC_ADD")
           " equation is useful
            for antialiasing and transparency, among other things. ")
     (para "
Initially, both the RGB blend equation and the alpha blend equation are set to "
           (code "GL_FUNC_ADD")
           ". ")
     (para)
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "mode")
           " is not one of "
           (code "GL_FUNC_ADD")
           ", "
           (code "GL_FUNC_SUBTRACT")
           ", "
           (code "GL_FUNC_REVERSE_SUBTRACT")
           ", "
           (code "GL_MAX")
           ", or "
           (code "GL_MIN")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glBlendEquation")
           " is executed
            between the execution of "
           (code "glBegin")
           " and the corresponding
            execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glBlendFuncSeparate
  "glBlendFuncSeparate"
  (funcsynopsis
    (funcprototype
      (funcdef
        "void "
        (function "glBlendFuncSeparate"))
      (paramdef "GLenum " (parameter "srcRGB"))
      (paramdef "GLenum " (parameter "dstRGB"))
      (paramdef "GLenum " (parameter "srcAlpha"))
      (paramdef "GLenum " (parameter "dstAlpha"))))
  '(*fragment*
     (heading
       "specify pixel arithmetic for RGB and alpha components separately")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "srcRGB")))
                   (para "
Specifies how the red, green, and blue blending factors are computed.
                    The following symbolic constants are accepted: "
                         (code "GL_ZERO")
                         ", "
                         (code "GL_ONE")
                         ", "
                         (code "GL_SRC_COLOR")
                         ", "
                         (code "GL_ONE_MINUS_SRC_COLOR")
                         ", "
                         (code "GL_DST_COLOR")
                         ", "
                         (code "GL_ONE_MINUS_DST_COLOR")
                         ", "
                         (code "GL_SRC_ALPHA")
                         ", "
                         (code "GL_ONE_MINUS_SRC_ALPHA")
                         ", "
                         (code "GL_DST_ALPHA")
                         ", "
                         (code "GL_ONE_MINUS_DST_ALPHA")
                         ", "
                         (code "GL_CONSTANT_COLOR")
                         ", "
                         (code "GL_ONE_MINUS_CONSTANT_COLOR")
                         ", "
                         (code "GL_CONSTANT_ALPHA")
                         ", "
                         (code "GL_ONE_MINUS_CONSTANT_ALPHA")
                         ", and "
                         (code "GL_SRC_ALPHA_SATURATE")
                         ".
                    The initial value is "
                         (code "GL_ONE")
                         ". "))
            (entry (% (heading (var "dstRGB")))
                   (para "
Specifies how the red, green, and blue destination blending factors are
                    computed. The following symbolic constants are accepted: "
                         (code "GL_ZERO")
                         ", "
                         (code "GL_ONE")
                         ", "
                         (code "GL_SRC_COLOR")
                         ", "
                         (code "GL_ONE_MINUS_SRC_COLOR")
                         ", "
                         (code "GL_DST_COLOR")
                         ", "
                         (code "GL_ONE_MINUS_DST_COLOR")
                         ", "
                         (code "GL_SRC_ALPHA")
                         ", "
                         (code "GL_ONE_MINUS_SRC_ALPHA")
                         ", "
                         (code "GL_DST_ALPHA")
                         ", "
                         (code "GL_ONE_MINUS_DST_ALPHA")
                         ". "
                         (code "GL_CONSTANT_COLOR")
                         ", "
                         (code "GL_ONE_MINUS_CONSTANT_COLOR")
                         ", "
                         (code "GL_CONSTANT_ALPHA")
                         ", and "
                         (code "GL_ONE_MINUS_CONSTANT_ALPHA")
                         ".
                    The initial value is "
                         (code "GL_ZERO")
                         ". "))
            (entry (% (heading (var "srcAlpha")))
                   (para "
Specified how the alpha source blending factor is computed.  The same
                    symbolic constants are accepted as for "
                         (var "srcRGB")
                         ".
                    The initial value is "
                         (code "GL_ONE")
                         ". "))
            (entry (% (heading (var "dstAlpha")))
                   (para "
Specified how the alpha destination blending factor is computed.  The same
                    symbolic constants are accepted as for "
                         (var "dstRGB")
                         ".
                    The initial value is "
                         (code "GL_ZERO")
                         ". ")))
     (heading "Description")
     (para "
In RGBA mode, pixels can be drawn using a function that blends
            the incoming (source) RGBA values with the RGBA values
            that are already in the frame buffer (the destination values).
            Blending is initially disabled.
            Use "
           (code "glEnable")
           " and "
           (code "glDisable")
           " with argument "
           (code "GL_BLEND")
           "
to enable and disable blending. ")
     (para (code "glBlendFuncSeparate")
           " defines the operation of blending when it is enabled. "
           (var "srcRGB")
           " specifies which method is used to scale the
            source RGB-color components. "
           (var "dstRGB")
           " specifies which method is used to scale the
            destination RGB-color components.
            Likewise, "
           (var "srcAlpha")
           " specifies which method is used to scale the source alpha
            color component, and "
           (var "dstAlpha")
           " specifies which method is used to scale the
            destination alpha component.
            The possible methods are described in the following table.
            Each method defines four scale factors,
            one each for red, green, blue, and alpha. ")
     (para "
In the table and in subsequent equations, source and destination
            color components are referred to as "
           (math "("
                 (var "R")
                 "_"
                 (var "s")
                 ","
                 (var "G")
                 "_"
                 (var "s")
                 (var "B")
                 "_"
                 (var "s")
                 (var "A")
                 "_"
                 (var "s")
                 ")")
           "
and "
           (math "("
                 (var "R")
                 "_"
                 (var "d")
                 ","
                 (var "G")
                 "_"
                 (var "d")
                 (var "B")
                 "_"
                 (var "d")
                 (var "A")
                 "_"
                 (var "d")
                 ")")
           ".
            The color specified by "
           (code "glBlendColor")
           " is referred to as "
           (math "("
                 (var "R")
                 "_"
                 (var "c")
                 ","
                 (var "G")
                 "_"
                 (var "c")
                 (var "B")
                 "_"
                 (var "c")
                 (var "A")
                 "_"
                 (var "c")
                 ")")
           ".
            They are understood to have integer values between 0 and "
           (math "("
                 (var "k")
                 "_"
                 (var "R")
                 ","
                 (var "k")
                 "_"
                 (var "G")
                 (var "k")
                 "_"
                 (var "B")
                 (var "k")
                 "_"
                 (var "A")
                 ")")
           ",
            where ")
     (para (para (math (var "k")
                       "_"
                       (var "c")
                       "="
                       "2"
                       "^"
                       (var "m")
                       "_"
                       (var "c")
                       ","
                       "-"
                       "1")))
     (para "
and "
           (math "("
                 (var "m")
                 "_"
                 (var "R")
                 ","
                 (var "m")
                 "_"
                 (var "G")
                 (var "m")
                 "_"
                 (var "B")
                 (var "m")
                 "_"
                 (var "A")
                 ")")
           "
is the number of red,
            green,
            blue,
            and alpha bitplanes. ")
     (para "
Source and destination scale factors are referred to as "
           (math "("
                 (var "s")
                 "_"
                 (var "R")
                 ","
                 (var "s")
                 "_"
                 (var "G")
                 (var "s")
                 "_"
                 (var "B")
                 (var "s")
                 "_"
                 (var "A")
                 ")")
           "
and "
           (math "("
                 (var "d")
                 "_"
                 (var "R")
                 ","
                 (var "d")
                 "_"
                 (var "G")
                 (var "d")
                 "_"
                 (var "B")
                 (var "d")
                 "_"
                 (var "A")
                 ")")
           ".
            All scale factors have range "
           (math "[" "0" "," "1" "]")
           ". ")
     (para)
     (table (% (formatter (asis)))
            (entry (% (heading (strong "Parameter")))
                   (para (strong "RGB Factor")
                         ", "
                         (strong "Alpha Factor")))
            (entry (% (heading (code "GL_ZERO")))
                   (para (math "(" "0" "," "0" "0" ")")
                         ", "
                         (math "0")))
            (entry (% (heading (code "GL_ONE")))
                   (para (math "(" "1" "," "1" "1" ")")
                         ", "
                         (math "1")))
            (entry (% (heading (code "GL_SRC_COLOR")))
                   (para (math "("
                               (var "R")
                               "_"
                               (var "s")
                               "/"
                               (var "k")
                               "_"
                               (var "R")
                               ","
                               (var "G")
                               "_"
                               (var "s")
                               "/"
                               (var "k")
                               "_"
                               (var "G")
                               (var "B")
                               "_"
                               (var "s")
                               "/"
                               (var "k")
                               "_"
                               (var "B")
                               ")")
                         ", "
                         (math (var "A")
                               "_"
                               (var "s")
                               "/"
                               (var "k")
                               "_"
                               (var "A"))))
            (entry (% (heading (code "GL_ONE_MINUS_SRC_COLOR")))
                   (para (math "("
                               "1"
                               ","
                               "1"
                               "1"
                               "1"
                               ")"
                               "-"
                               "("
                               (var "R")
                               "_"
                               (var "s")
                               "/"
                               (var "k")
                               "_"
                               (var "R")
                               ","
                               (var "G")
                               "_"
                               (var "s")
                               "/"
                               (var "k")
                               "_"
                               (var "G")
                               (var "B")
                               "_"
                               (var "s")
                               "/"
                               (var "k")
                               "_"
                               (var "B")
                               ")")
                         ", "
                         (math "1"
                               "-"
                               (var "A")
                               "_"
                               (var "s")
                               "/"
                               (var "k")
                               "_"
                               (var "A"))))
            (entry (% (heading (code "GL_DST_COLOR")))
                   (para (math "("
                               (var "R")
                               "_"
                               (var "d")
                               "/"
                               (var "k")
                               "_"
                               (var "R")
                               ","
                               (var "G")
                               "_"
                               (var "d")
                               "/"
                               (var "k")
                               "_"
                               (var "G")
                               (var "B")
                               "_"
                               (var "d")
                               "/"
                               (var "k")
                               "_"
                               (var "B")
                               ")")
                         ", "
                         (math (var "A")
                               "_"
                               (var "d")
                               "/"
                               (var "k")
                               "_"
                               (var "A"))))
            (entry (% (heading (code "GL_ONE_MINUS_DST_COLOR")))
                   (para (math "("
                               "1"
                               ","
                               "1"
                               "1"
                               ")"
                               "-"
                               "("
                               (var "R")
                               "_"
                               (var "d")
                               "/"
                               (var "k")
                               "_"
                               (var "R")
                               ","
                               (var "G")
                               "_"
                               (var "d")
                               "/"
                               (var "k")
                               "_"
                               (var "G")
                               (var "B")
                               "_"
                               (var "d")
                               "/"
                               (var "k")
                               "_"
                               (var "B")
                               ")")
                         ", "
                         (math "1"
                               "-"
                               (var "A")
                               "_"
                               (var "d")
                               "/"
                               (var "k")
                               "_"
                               (var "A"))))
            (entry (% (heading (code "GL_SRC_ALPHA")))
                   (para (math "("
                               (var "A")
                               "_"
                               (var "s")
                               "/"
                               (var "k")
                               "_"
                               (var "A")
                               ","
                               (var "A")
                               "_"
                               (var "s")
                               "/"
                               (var "k")
                               "_"
                               (var "A")
                               (var "A")
                               "_"
                               (var "s")
                               "/"
                               (var "k")
                               "_"
                               (var "A")
                               ")")
                         ", "
                         (math (var "A")
                               "_"
                               (var "s")
                               "/"
                               (var "k")
                               "_"
                               (var "A"))))
            (entry (% (heading (code "GL_ONE_MINUS_SRC_ALPHA")))
                   (para (math "("
                               "1"
                               ","
                               "1"
                               "1"
                               ")"
                               "-"
                               "("
                               (var "A")
                               "_"
                               (var "s")
                               "/"
                               (var "k")
                               "_"
                               (var "A")
                               ","
                               (var "A")
                               "_"
                               (var "s")
                               "/"
                               (var "k")
                               "_"
                               (var "A")
                               (var "A")
                               "_"
                               (var "s")
                               "/"
                               (var "k")
                               "_"
                               (var "A")
                               ")")
                         ", "
                         (math "1"
                               "-"
                               (var "A")
                               "_"
                               (var "s")
                               "/"
                               (var "k")
                               "_"
                               (var "A"))))
            (entry (% (heading (code "GL_DST_ALPHA")))
                   (para (math "("
                               (var "A")
                               "_"
                               (var "d")
                               "/"
                               (var "k")
                               "_"
                               (var "A")
                               ","
                               (var "A")
                               "_"
                               (var "d")
                               "/"
                               (var "k")
                               "_"
                               (var "A")
                               (var "A")
                               "_"
                               (var "d")
                               "/"
                               (var "k")
                               "_"
                               (var "A")
                               ")")
                         ", "
                         (math (var "A")
                               "_"
                               (var "d")
                               "/"
                               (var "k")
                               "_"
                               (var "A"))))
            (entry (% (heading (code "GL_ONE_MINUS_DST_ALPHA")))
                   (para (math "("
                               "1"
                               ","
                               "1"
                               "1"
                               ")"
                               "-"
                               "("
                               (var "A")
                               "_"
                               (var "d")
                               "/"
                               (var "k")
                               "_"
                               (var "A")
                               ","
                               (var "A")
                               "_"
                               (var "d")
                               "/"
                               (var "k")
                               "_"
                               (var "A")
                               (var "A")
                               "_"
                               (var "d")
                               "/"
                               (var "k")
                               "_"
                               (var "A")
                               ")")
                         ", "
                         (math "1"
                               "-"
                               (var "A")
                               "_"
                               (var "d")
                               "/"
                               (var "k")
                               "_"
                               (var "A"))))
            (entry (% (heading (code "GL_CONSTANT_COLOR")))
                   (para (math "("
                               (var "R")
                               "_"
                               (var "c")
                               ","
                               (var "G")
                               "_"
                               (var "c")
                               (var "B")
                               "_"
                               (var "c")
                               ")")
                         ", "
                         (math (var "A") "_" (var "c"))))
            (entry (% (heading (code "GL_ONE_MINUS_CONSTANT_COLOR")))
                   (para (math "("
                               "1"
                               ","
                               "1"
                               "1"
                               ")"
                               "-"
                               "("
                               (var "R")
                               "_"
                               (var "c")
                               ","
                               (var "G")
                               "_"
                               (var "c")
                               (var "B")
                               "_"
                               (var "c")
                               ")")
                         ", "
                         (math "1" "-" (var "A") "_" (var "c"))))
            (entry (% (heading (code "GL_CONSTANT_ALPHA")))
                   (para (math "("
                               (var "A")
                               "_"
                               (var "c")
                               ","
                               (var "A")
                               "_"
                               (var "c")
                               (var "A")
                               "_"
                               (var "c")
                               ")")
                         ", "
                         (math (var "A") "_" (var "c"))))
            (entry (% (heading (code "GL_ONE_MINUS_CONSTANT_ALPHA")))
                   (para (math "("
                               "1"
                               ","
                               "1"
                               "1"
                               ")"
                               "-"
                               "("
                               (var "A")
                               "_"
                               (var "c")
                               ","
                               (var "A")
                               "_"
                               (var "c")
                               (var "A")
                               "_"
                               (var "c")
                               ")")
                         ", "
                         (math "1" "-" (var "A") "_" (var "c"))))
            (entry (% (heading (code "GL_SRC_ALPHA_SATURATE")))
                   (para (math "(" (var "i") "," (var "i") (var "i") ")")
                         ", "
                         (math "1"))))
     (para "
In the table, ")
     (para (para (math (var "i")
                       "="
                       (var "min")
                       "\u2061"
                       "("
                       (var "A")
                       "_"
                       (var "s")
                       ","
                       "1"
                       "-"
                       (var "A")
                       "_"
                       (var "d")
                       ","
                       ")")))
     (para "
To determine the blended RGBA values of a pixel when drawing in RGBA mode,
            the system uses the following equations: ")
     (para (para (math (var "R")
                       "_"
                       (var "d")
                       "="
                       (var "min")
                       "\u2061"
                       "("
                       (var "k")
                       "_"
                       (var "R")
                       ","
                       (var "R")
                       "_"
                       (var "s")
                       "\u2062"
                       (var "s")
                       "_"
                       (var "R")
                       "+"
                       (var "R")
                       "_"
                       (var "d")
                       "\u2062"
                       (var "d")
                       "_"
                       (var "R")
                       ")")
                 (math (var "G")
                       "_"
                       (var "d")
                       "="
                       (var "min")
                       "\u2061"
                       "("
                       (var "k")
                       "_"
                       (var "G")
                       ","
                       (var "G")
                       "_"
                       (var "s")
                       "\u2062"
                       (var "s")
                       "_"
                       (var "G")
                       "+"
                       (var "G")
                       "_"
                       (var "d")
                       "\u2062"
                       (var "d")
                       "_"
                       (var "G")
                       ")")
                 (math (var "B")
                       "_"
                       (var "d")
                       "="
                       (var "min")
                       "\u2061"
                       "("
                       (var "k")
                       "_"
                       (var "B")
                       ","
                       (var "B")
                       "_"
                       (var "s")
                       "\u2062"
                       (var "s")
                       "_"
                       (var "B")
                       "+"
                       (var "B")
                       "_"
                       (var "d")
                       "\u2062"
                       (var "d")
                       "_"
                       (var "B")
                       ")")
                 (math (var "A")
                       "_"
                       (var "d")
                       "="
                       (var "min")
                       "\u2061"
                       "("
                       (var "k")
                       "_"
                       (var "A")
                       ","
                       (var "A")
                       "_"
                       (var "s")
                       "\u2062"
                       (var "s")
                       "_"
                       (var "A")
                       "+"
                       (var "A")
                       "_"
                       (var "d")
                       "\u2062"
                       (var "d")
                       "_"
                       (var "A")
                       ")")))
     (para "
Despite the apparent precision of the above equations, blending arithmetic
            is not exactly specified, because blending operates with imprecise integer
            color values.  However, a blend factor that should be equal to 1 is
            guaranteed not to modify its multiplicand, and a blend factor equal to 0
            reduces its multiplicand to 0.  For example, when "
           (var "srcRGB")
           " is "
           (code "GL_SRC_ALPHA")
           ", "
           (var "dstRGB")
           " is "
           (code "GL_ONE_MINUS_SRC_ALPHA")
           ", and "
           (math (var "A") "_" (var "s"))
           "
is
            equal to "
           (math (var "k") "_" (var "A"))
           ",
            the equations reduce to simple replacement: ")
     (para (para (math (var "R")
                       "_"
                       (var "d")
                       "="
                       (var "R")
                       "_"
                       (var "s"))
                 (math (var "G")
                       "_"
                       (var "d")
                       "="
                       (var "G")
                       "_"
                       (var "s"))
                 (math (var "B")
                       "_"
                       (var "d")
                       "="
                       (var "B")
                       "_"
                       (var "s"))
                 (math (var "A")
                       "_"
                       (var "d")
                       "="
                       (var "A")
                       "_"
                       (var "s"))))
     (para)
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if either "
           (var "srcRGB")
           " or "
           (var "dstRGB")
           " is not an
            accepted value. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glBlendFuncSeparate")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glBlendFunc
  "glBlendFunc"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glBlendFunc"))
      (paramdef "GLenum " (parameter "sfactor"))
      (paramdef "GLenum " (parameter "dfactor"))))
  '(*fragment*
     (heading "specify pixel arithmetic")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "sfactor")))
                   (para "
Specifies how the red, green, blue,
                    and alpha source blending factors are computed.
                    The following symbolic constants are accepted: "
                         (code "GL_ZERO")
                         ", "
                         (code "GL_ONE")
                         ", "
                         (code "GL_SRC_COLOR")
                         ", "
                         (code "GL_ONE_MINUS_SRC_COLOR")
                         ", "
                         (code "GL_DST_COLOR")
                         ", "
                         (code "GL_ONE_MINUS_DST_COLOR")
                         ", "
                         (code "GL_SRC_ALPHA")
                         ", "
                         (code "GL_ONE_MINUS_SRC_ALPHA")
                         ", "
                         (code "GL_DST_ALPHA")
                         ", "
                         (code "GL_ONE_MINUS_DST_ALPHA")
                         ", "
                         (code "GL_CONSTANT_COLOR")
                         ", "
                         (code "GL_ONE_MINUS_CONSTANT_COLOR")
                         ", "
                         (code "GL_CONSTANT_ALPHA")
                         ", "
                         (code "GL_ONE_MINUS_CONSTANT_ALPHA")
                         ", and "
                         (code "GL_SRC_ALPHA_SATURATE")
                         ".
                    The initial value is "
                         (code "GL_ONE")
                         ". "))
            (entry (% (heading (var "dfactor")))
                   (para "
Specifies how the red, green, blue,
                    and alpha destination blending factors are computed.
                    The following symbolic constants are accepted: "
                         (code "GL_ZERO")
                         ", "
                         (code "GL_ONE")
                         ", "
                         (code "GL_SRC_COLOR")
                         ", "
                         (code "GL_ONE_MINUS_SRC_COLOR")
                         ", "
                         (code "GL_DST_COLOR")
                         ", "
                         (code "GL_ONE_MINUS_DST_COLOR")
                         ", "
                         (code "GL_SRC_ALPHA")
                         ", "
                         (code "GL_ONE_MINUS_SRC_ALPHA")
                         ", "
                         (code "GL_DST_ALPHA")
                         ", "
                         (code "GL_ONE_MINUS_DST_ALPHA")
                         ". "
                         (code "GL_CONSTANT_COLOR")
                         ", "
                         (code "GL_ONE_MINUS_CONSTANT_COLOR")
                         ", "
                         (code "GL_CONSTANT_ALPHA")
                         ", and "
                         (code "GL_ONE_MINUS_CONSTANT_ALPHA")
                         ".
                    The initial value is "
                         (code "GL_ZERO")
                         ". ")))
     (heading "Description")
     (para "
In RGBA mode, pixels can be drawn using a function that blends
            the incoming (source) RGBA values with the RGBA values
            that are already in the frame buffer (the destination values).
            Blending is initially disabled.
            Use "
           (code "glEnable")
           " and "
           (code "glDisable")
           " with argument "
           (code "GL_BLEND")
           "
to enable and disable blending. ")
     (para (code "glBlendFunc")
           " defines the operation of blending when it is enabled. "
           (var "sfactor")
           " specifies which method is used to scale the
            source color components. "
           (var "dfactor")
           " specifies which method is used to scale the
            destination color components.
            The possible methods are described in the following table.
            Each method defines four scale factors,
            one each for red, green, blue, and alpha.
            In the table and in subsequent equations, source and destination
            color components are referred to as "
           (math "("
                 (var "R")
                 "_"
                 (var "s")
                 ","
                 (var "G")
                 "_"
                 (var "s")
                 (var "B")
                 "_"
                 (var "s")
                 (var "A")
                 "_"
                 (var "s")
                 ")")
           "
and "
           (math "("
                 (var "R")
                 "_"
                 (var "d")
                 ","
                 (var "G")
                 "_"
                 (var "d")
                 (var "B")
                 "_"
                 (var "d")
                 (var "A")
                 "_"
                 (var "d")
                 ")")
           ".
            The color specified by "
           (code "glBlendColor")
           " is referred to as "
           (math "("
                 (var "R")
                 "_"
                 (var "c")
                 ","
                 (var "G")
                 "_"
                 (var "c")
                 (var "B")
                 "_"
                 (var "c")
                 (var "A")
                 "_"
                 (var "c")
                 ")")
           ".
            They are understood to have integer values between 0 and "
           (math "("
                 (var "k")
                 "_"
                 (var "R")
                 ","
                 (var "k")
                 "_"
                 (var "G")
                 (var "k")
                 "_"
                 (var "B")
                 (var "k")
                 "_"
                 (var "A")
                 ")")
           ",
            where ")
     (para (para (math (var "k")
                       "_"
                       (var "c")
                       "="
                       "2"
                       "^"
                       (var "m")
                       "_"
                       (var "c")
                       ","
                       "-"
                       "1")))
     (para "
and "
           (math "("
                 (var "m")
                 "_"
                 (var "R")
                 ","
                 (var "m")
                 "_"
                 (var "G")
                 (var "m")
                 "_"
                 (var "B")
                 (var "m")
                 "_"
                 (var "A")
                 ")")
           "
is the number of red,
            green,
            blue,
            and alpha bitplanes. ")
     (para "
Source and destination scale factors are referred to as "
           (math "("
                 (var "s")
                 "_"
                 (var "R")
                 ","
                 (var "s")
                 "_"
                 (var "G")
                 (var "s")
                 "_"
                 (var "B")
                 (var "s")
                 "_"
                 (var "A")
                 ")")
           "
and "
           (math "("
                 (var "d")
                 "_"
                 (var "R")
                 ","
                 (var "d")
                 "_"
                 (var "G")
                 (var "d")
                 "_"
                 (var "B")
                 (var "d")
                 "_"
                 (var "A")
                 ")")
           ".
            The scale factors described in the table,
            denoted "
           (math "("
                 (var "f")
                 "_"
                 (var "R")
                 ","
                 (var "f")
                 "_"
                 (var "G")
                 (var "f")
                 "_"
                 (var "B")
                 (var "f")
                 "_"
                 (var "A")
                 ")")
           ",
            represent either source or destination factors.
            All scale factors have range "
           (math "[" "0" "," "1" "]")
           ". ")
     (para)
     (table (% (formatter (asis)))
            (entry (% (heading (strong "Parameter")))
                   (para (strong
                           (math "("
                                 (var "f")
                                 "_"
                                 (var "R")
                                 ","
                                 (var "f")
                                 "_"
                                 (var "G")
                                 (var "f")
                                 "_"
                                 (var "B")
                                 (var "f")
                                 "_"
                                 (var "A")
                                 ")"))))
            (entry (% (heading (code "GL_ZERO")))
                   (para (math "(" "0" "," "0" "0" "0" ")")))
            (entry (% (heading (code "GL_ONE")))
                   (para (math "(" "1" "," "1" "1" "1" ")")))
            (entry (% (heading (code "GL_SRC_COLOR")))
                   (para (math "("
                               (var "R")
                               "_"
                               (var "s")
                               "/"
                               (var "k")
                               "_"
                               (var "R")
                               ","
                               (var "G")
                               "_"
                               (var "s")
                               "/"
                               (var "k")
                               "_"
                               (var "G")
                               (var "B")
                               "_"
                               (var "s")
                               "/"
                               (var "k")
                               "_"
                               (var "B")
                               (var "A")
                               "_"
                               (var "s")
                               "/"
                               (var "k")
                               "_"
                               (var "A")
                               ")")))
            (entry (% (heading (code "GL_ONE_MINUS_SRC_COLOR")))
                   (para (math "("
                               "1"
                               ","
                               "1"
                               "1"
                               "1"
                               ")"
                               "-"
                               "("
                               (var "R")
                               "_"
                               (var "s")
                               "/"
                               (var "k")
                               "_"
                               (var "R")
                               ","
                               (var "G")
                               "_"
                               (var "s")
                               "/"
                               (var "k")
                               "_"
                               (var "G")
                               (var "B")
                               "_"
                               (var "s")
                               "/"
                               (var "k")
                               "_"
                               (var "B")
                               (var "A")
                               "_"
                               (var "s")
                               "/"
                               (var "k")
                               "_"
                               (var "A")
                               ")")))
            (entry (% (heading (code "GL_DST_COLOR")))
                   (para (math "("
                               (var "R")
                               "_"
                               (var "d")
                               "/"
                               (var "k")
                               "_"
                               (var "R")
                               ","
                               (var "G")
                               "_"
                               (var "d")
                               "/"
                               (var "k")
                               "_"
                               (var "G")
                               (var "B")
                               "_"
                               (var "d")
                               "/"
                               (var "k")
                               "_"
                               (var "B")
                               (var "A")
                               "_"
                               (var "d")
                               "/"
                               (var "k")
                               "_"
                               (var "A")
                               ")")))
            (entry (% (heading (code "GL_ONE_MINUS_DST_COLOR")))
                   (para (math "("
                               "1"
                               ","
                               "1"
                               "1"
                               "1"
                               ")"
                               "-"
                               "("
                               (var "R")
                               "_"
                               (var "d")
                               "/"
                               (var "k")
                               "_"
                               (var "R")
                               ","
                               (var "G")
                               "_"
                               (var "d")
                               "/"
                               (var "k")
                               "_"
                               (var "G")
                               (var "B")
                               "_"
                               (var "d")
                               "/"
                               (var "k")
                               "_"
                               (var "B")
                               (var "A")
                               "_"
                               (var "d")
                               "/"
                               (var "k")
                               "_"
                               (var "A")
                               ")")))
            (entry (% (heading (code "GL_SRC_ALPHA")))
                   (para (math "("
                               (var "A")
                               "_"
                               (var "s")
                               "/"
                               (var "k")
                               "_"
                               (var "A")
                               ","
                               (var "A")
                               "_"
                               (var "s")
                               "/"
                               (var "k")
                               "_"
                               (var "A")
                               (var "A")
                               "_"
                               (var "s")
                               "/"
                               (var "k")
                               "_"
                               (var "A")
                               (var "A")
                               "_"
                               (var "s")
                               "/"
                               (var "k")
                               "_"
                               (var "A")
                               ")")))
            (entry (% (heading (code "GL_ONE_MINUS_SRC_ALPHA")))
                   (para (math "("
                               "1"
                               ","
                               "1"
                               "1"
                               "1"
                               ")"
                               "-"
                               "("
                               (var "A")
                               "_"
                               (var "s")
                               "/"
                               (var "k")
                               "_"
                               (var "A")
                               ","
                               (var "A")
                               "_"
                               (var "s")
                               "/"
                               (var "k")
                               "_"
                               (var "A")
                               (var "A")
                               "_"
                               (var "s")
                               "/"
                               (var "k")
                               "_"
                               (var "A")
                               (var "A")
                               "_"
                               (var "s")
                               "/"
                               (var "k")
                               "_"
                               (var "A")
                               ")")))
            (entry (% (heading (code "GL_DST_ALPHA")))
                   (para (math "("
                               (var "A")
                               "_"
                               (var "d")
                               "/"
                               (var "k")
                               "_"
                               (var "A")
                               ","
                               (var "A")
                               "_"
                               (var "d")
                               "/"
                               (var "k")
                               "_"
                               (var "A")
                               (var "A")
                               "_"
                               (var "d")
                               "/"
                               (var "k")
                               "_"
                               (var "A")
                               (var "A")
                               "_"
                               (var "d")
                               "/"
                               (var "k")
                               "_"
                               (var "A")
                               ")")))
            (entry (% (heading (code "GL_ONE_MINUS_DST_ALPHA")))
                   (para (math "("
                               "1"
                               ","
                               "1"
                               "1"
                               "1"
                               ")"
                               "-"
                               "("
                               (var "A")
                               "_"
                               (var "d")
                               "/"
                               (var "k")
                               "_"
                               (var "A")
                               ","
                               (var "A")
                               "_"
                               (var "d")
                               "/"
                               (var "k")
                               "_"
                               (var "A")
                               (var "A")
                               "_"
                               (var "d")
                               "/"
                               (var "k")
                               "_"
                               (var "A")
                               (var "A")
                               "_"
                               (var "d")
                               "/"
                               (var "k")
                               "_"
                               (var "A")
                               ")")))
            (entry (% (heading (code "GL_CONSTANT_COLOR")))
                   (para (math "("
                               (var "R")
                               "_"
                               (var "c")
                               ","
                               (var "G")
                               "_"
                               (var "c")
                               (var "B")
                               "_"
                               (var "c")
                               (var "A")
                               "_"
                               (var "c")
                               ")")))
            (entry (% (heading (code "GL_ONE_MINUS_CONSTANT_COLOR")))
                   (para (math "("
                               "1"
                               ","
                               "1"
                               "1"
                               "1"
                               ")"
                               "-"
                               "("
                               (var "R")
                               "_"
                               (var "c")
                               ","
                               (var "G")
                               "_"
                               (var "c")
                               (var "B")
                               "_"
                               (var "c")
                               (var "A")
                               "_"
                               (var "c")
                               ")")))
            (entry (% (heading (code "GL_CONSTANT_ALPHA")))
                   (para (math "("
                               (var "A")
                               "_"
                               (var "c")
                               ","
                               (var "A")
                               "_"
                               (var "c")
                               (var "A")
                               "_"
                               (var "c")
                               (var "A")
                               "_"
                               (var "c")
                               ")")))
            (entry (% (heading (code "GL_ONE_MINUS_CONSTANT_ALPHA")))
                   (para (math "("
                               "1"
                               ","
                               "1"
                               "1"
                               "1"
                               ")"
                               "-"
                               "("
                               (var "A")
                               "_"
                               (var "c")
                               ","
                               (var "A")
                               "_"
                               (var "c")
                               (var "A")
                               "_"
                               (var "c")
                               (var "A")
                               "_"
                               (var "c")
                               ")")))
            (entry (% (heading (code "GL_SRC_ALPHA_SATURATE")))
                   (para (math "("
                               (var "i")
                               ","
                               (var "i")
                               (var "i")
                               "1"
                               ")"))))
     (para "
In the table, ")
     (para (para (math (var "i")
                       "="
                       (var "min")
                       "\u2061"
                       "("
                       (var "A")
                       "_"
                       (var "s")
                       ","
                       (var "k")
                       "_"
                       (var "A")
                       "-"
                       (var "A")
                       "_"
                       (var "d")
                       ")"
                       "/"
                       (var "k")
                       "_"
                       (var "A"))))
     (para "
To determine the blended RGBA values of a pixel when drawing in RGBA mode,
            the system uses the following equations: ")
     (para (para (math (var "R")
                       "_"
                       (var "d")
                       "="
                       (var "min")
                       "\u2061"
                       "("
                       (var "k")
                       "_"
                       (var "R")
                       ","
                       (var "R")
                       "_"
                       (var "s")
                       "\u2062"
                       (var "s")
                       "_"
                       (var "R")
                       "+"
                       (var "R")
                       "_"
                       (var "d")
                       "\u2062"
                       (var "d")
                       "_"
                       (var "R")
                       ")")
                 (math (var "G")
                       "_"
                       (var "d")
                       "="
                       (var "min")
                       "\u2061"
                       "("
                       (var "k")
                       "_"
                       (var "G")
                       ","
                       (var "G")
                       "_"
                       (var "s")
                       "\u2062"
                       (var "s")
                       "_"
                       (var "G")
                       "+"
                       (var "G")
                       "_"
                       (var "d")
                       "\u2062"
                       (var "d")
                       "_"
                       (var "G")
                       ")")
                 (math (var "B")
                       "_"
                       (var "d")
                       "="
                       (var "min")
                       "\u2061"
                       "("
                       (var "k")
                       "_"
                       (var "B")
                       ","
                       (var "B")
                       "_"
                       (var "s")
                       "\u2062"
                       (var "s")
                       "_"
                       (var "B")
                       "+"
                       (var "B")
                       "_"
                       (var "d")
                       "\u2062"
                       (var "d")
                       "_"
                       (var "B")
                       ")")
                 (math (var "A")
                       "_"
                       (var "d")
                       "="
                       (var "min")
                       "\u2061"
                       "("
                       (var "k")
                       "_"
                       (var "A")
                       ","
                       (var "A")
                       "_"
                       (var "s")
                       "\u2062"
                       (var "s")
                       "_"
                       (var "A")
                       "+"
                       (var "A")
                       "_"
                       (var "d")
                       "\u2062"
                       (var "d")
                       "_"
                       (var "A")
                       ")")))
     (para "
Despite the apparent precision of the above equations,
            blending arithmetic is not exactly specified,
            because blending operates with imprecise integer color values.
            However,
            a blend factor that should be equal to 1
            is guaranteed not to modify its multiplicand,
            and a blend factor equal to 0 reduces its multiplicand to 0.
            For example,
            when "
           (var "sfactor")
           " is "
           (code "GL_SRC_ALPHA")
           ", "
           (var "dfactor")
           " is "
           (code "GL_ONE_MINUS_SRC_ALPHA")
           ",
            and "
           (math (var "A") "_" (var "s"))
           "
is equal to "
           (math (var "k") "_" (var "A"))
           ",
            the equations reduce to simple replacement: ")
     (para (para (math (var "R")
                       "_"
                       (var "d")
                       "="
                       (var "R")
                       "_"
                       (var "s"))
                 (math (var "G")
                       "_"
                       (var "d")
                       "="
                       (var "G")
                       "_"
                       (var "s"))
                 (math (var "B")
                       "_"
                       (var "d")
                       "="
                       (var "B")
                       "_"
                       (var "s"))
                 (math (var "A")
                       "_"
                       (var "d")
                       "="
                       (var "A")
                       "_"
                       (var "s"))))
     (para)
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if either "
           (var "sfactor")
           " or "
           (var "dfactor")
           " is not an
            accepted value. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glBlendFunc")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glBufferData
  "glBufferData"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glBufferData"))
      (paramdef "GLenum " (parameter "target"))
      (paramdef "GLsizeiptr " (parameter "size"))
      (paramdef "const GLvoid * " (parameter "data"))
      (paramdef "GLenum " (parameter "usage"))))
  '(*fragment*
     (heading
       "creates and initializes a buffer object's data store")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "target")))
                   (para "
Specifies the target buffer object.
                    The symbolic constant must be "
                         (code "GL_ARRAY_BUFFER")
                         ", "
                         (code "GL_ELEMENT_ARRAY_BUFFER")
                         ", "
                         (code "GL_PIXEL_PACK_BUFFER")
                         ", or "
                         (code "GL_PIXEL_UNPACK_BUFFER")
                         ". "))
            (entry (% (heading (var "size")))
                   (para "
Specifies the size in bytes of the buffer object's new data store. "))
            (entry (% (heading (var "data")))
                   (para "
Specifies a pointer to data that will be copied into the data store for initialization,
                    or "
                         (code "NULL")
                         " if no data is to be copied. "))
            (entry (% (heading (var "usage")))
                   (para "
Specifies the expected usage pattern of the data store. The symbolic constant must be "
                         (code "GL_STREAM_DRAW")
                         ", "
                         (code "GL_STREAM_READ")
                         ", "
                         (code "GL_STREAM_COPY")
                         ", "
                         (code "GL_STATIC_DRAW")
                         ", "
                         (code "GL_STATIC_READ")
                         ", "
                         (code "GL_STATIC_COPY")
                         ", "
                         (code "GL_DYNAMIC_DRAW")
                         ", "
                         (code "GL_DYNAMIC_READ")
                         ", or "
                         (code "GL_DYNAMIC_COPY")
                         ". ")))
     (heading "Description")
     (para (code "glBufferData")
           " creates a new data store for the buffer object currently bound to "
           (var "target")
           ". Any pre-existing data store is deleted. The new data store is created with the
            specified "
           (var "size")
           " in bytes and "
           (var "usage")
           ". If "
           (var "data")
           "
is not "
           (code "NULL")
           ", the data store is initialized with data from this pointer. In its initial 
            state, the new data store is not mapped, it has a "
           (code "NULL")
           " mapped pointer, and its mapped access 
            is "
           (code "GL_READ_WRITE")
           ". ")
     (para (var "usage")
           " is a hint to the GL implementation as to how a buffer object's data store will be 
            accessed. This enables the GL implementation to make more intelligent decisions that may significantly 
            impact buffer object performance. It does not, however, constrain the actual usage of the data store. "
           (var "usage")
           " can be broken down into two parts: first, the frequency of access (modification 
            and usage), and second, the nature of that access. The frequency of access may be one of these: ")
     (table (% (formatter (asis)))
            (entry (% (heading "STREAM"))
                   (para "
The data store contents will be modified once and used at most a few times. "))
            (entry (% (heading "STATIC"))
                   (para "
The data store contents will be modified once and used many times. "))
            (entry (% (heading "DYNAMIC"))
                   (para "
The data store contents will be modified repeatedly and used many times. ")))
     (para "
The nature of access may be one of these: ")
     (table (% (formatter (asis)))
            (entry (% (heading "DRAW"))
                   (para "
The data store contents are modified by the application, and used as the source for GL drawing and
                        image specification commands. "))
            (entry (% (heading "READ"))
                   (para "
The data store contents are modified by reading data from the GL, and used to return that data 
                        when queried by the application. "))
            (entry (% (heading "COPY"))
                   (para "
The data store contents are modified by reading data from the GL, and used as the source for GL
                        drawing and image specification commands. ")))
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "target")
           " is not "
           (code "GL_ARRAY_BUFFER")
           ", "
           (code "GL_ELEMENT_ARRAY_BUFFER")
           ", "
           (code "GL_PIXEL_PACK_BUFFER")
           ", or "
           (code "GL_PIXEL_UNPACK_BUFFER")
           ". ")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "usage")
           " is not "
           (code "GL_STREAM_DRAW")
           ", "
           (code "GL_STREAM_READ")
           ", "
           (code "GL_STREAM_COPY")
           ", "
           (code "GL_STATIC_DRAW")
           ", "
           (code "GL_STATIC_READ")
           ", "
           (code "GL_STATIC_COPY")
           ", "
           (code "GL_DYNAMIC_DRAW")
           ", "
           (code "GL_DYNAMIC_READ")
           ", or "
           (code "GL_DYNAMIC_COPY")
           ". ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "size")
           " is negative. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if the reserved buffer object name 0 is bound to "
           (var "target")
           ". ")
     (para (code "GL_OUT_OF_MEMORY")
           " is generated if the GL is unable to create a data store with the specified "
           (var "size")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glBufferData")
           "
is executed between the execution of "
           (code "glBegin")
           " and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glBufferSubData
  "glBufferSubData"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glBufferSubData"))
      (paramdef "GLenum " (parameter "target"))
      (paramdef "GLintptr " (parameter "offset"))
      (paramdef "GLsizeiptr " (parameter "size"))
      (paramdef "const GLvoid * " (parameter "data"))))
  '(*fragment*
     (heading
       "updates a subset of a buffer object's data store")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "target")))
                   (para "
Specifies the target buffer object.
                    The symbolic constant must be "
                         (code "GL_ARRAY_BUFFER")
                         ", "
                         (code "GL_ELEMENT_ARRAY_BUFFER")
                         ", "
                         (code "GL_PIXEL_PACK_BUFFER")
                         ", or "
                         (code "GL_PIXEL_UNPACK_BUFFER")
                         ". "))
            (entry (% (heading (var "offset")))
                   (para "
Specifies the offset into the buffer object's data store where data replacement will begin,
                    measured in bytes. "))
            (entry (% (heading (var "size")))
                   (para "
Specifies the size in bytes of the data store region being replaced. "))
            (entry (% (heading (var "data")))
                   (para "
Specifies a pointer to the new data that will be copied into the data store. ")))
     (heading "Description")
     (para (code "glBufferSubData")
           " redefines some or all of the data store for the buffer object currently 
            bound to "
           (var "target")
           ". Data starting at byte offset "
           (var "offset")
           " and
            extending for "
           (var "size")
           " bytes is copied to the data store from the memory pointed to by "
           (var "data")
           ".  An error is thrown if "
           (var "offset")
           " and "
           (var "size")
           "
together define a range beyond the bounds of the buffer object's data store. ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "target")
           " is not "
           (code "GL_ARRAY_BUFFER")
           ", "
           (code "GL_ELEMENT_ARRAY_BUFFER")
           ", "
           (code "GL_PIXEL_PACK_BUFFER")
           ", or "
           (code "GL_PIXEL_UNPACK_BUFFER")
           ". ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "offset")
           " or "
           (var "size")
           " is negative, or if together they define a region of memory
            that extends beyond the buffer object's allocated data store. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if the reserved buffer object name 0 is bound to "
           (var "target")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if the buffer object being updated is mapped. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glBufferSubData")
           "
is executed between the execution of "
           (code "glBegin")
           " and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glCallLists
  "glCallLists"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glCallLists"))
      (paramdef "GLsizei " (parameter "n"))
      (paramdef "GLenum " (parameter "type"))
      (paramdef "const GLvoid * " (parameter "lists"))))
  '(*fragment*
     (heading "execute a list of display lists")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "n")))
                   (para "
Specifies the number of display lists to be executed. "))
            (entry (% (heading (var "type")))
                   (para "
Specifies the type of values in "
                         (var "lists")
                         ".
                    Symbolic constants "
                         (code "GL_BYTE")
                         ", "
                         (code "GL_UNSIGNED_BYTE")
                         ", "
                         (code "GL_SHORT")
                         ", "
                         (code "GL_UNSIGNED_SHORT")
                         ", "
                         (code "GL_INT")
                         ", "
                         (code "GL_UNSIGNED_INT")
                         ", "
                         (code "GL_FLOAT")
                         ", "
                         (code "GL_2_BYTES")
                         ", "
                         (code "GL_3_BYTES")
                         ", and "
                         (code "GL_4_BYTES")
                         " are accepted. "))
            (entry (% (heading (var "lists")))
                   (para "
Specifies the address of an array of name offsets in the display list.
                    The pointer type is void because the offsets can be bytes,
                    shorts,
                    ints,
                    or floats,
                    depending on the value of "
                         (var "type")
                         ". ")))
     (heading "Description")
     (para (code "glCallLists")
           " causes each display list in the list of names passed as "
           (var "lists")
           "
to be executed.
            As a result,
            the commands saved in each display list are executed in order,
            just as if they were called without using a display list.
            Names of display lists that have not been defined are ignored. ")
     (para (code "glCallLists")
           " provides an efficient means for executing more than one display list. "
           (var "type")
           " allows lists with various name formats to be accepted.
            The formats are as
            follows: ")
     (table (% (formatter (asis)))
            (entry (% (heading (code "GL_BYTE")))
                   (para (var "lists")
                         " is treated as an array of signed bytes,
                        each in the range "
                         (math "-128")
                         "
through 127. "))
            (entry (% (heading (code "GL_UNSIGNED_BYTE")))
                   (para (var "lists")
                         " is treated as an array of unsigned bytes,
                        each in the range 0 through 255. "))
            (entry (% (heading (code "GL_SHORT")))
                   (para (var "lists")
                         " is treated as an array of signed two-byte integers,
                        each in the range "
                         (math "-32768")
                         "
through 32767. "))
            (entry (% (heading (code "GL_UNSIGNED_SHORT")))
                   (para (var "lists")
                         " is treated as an array of unsigned two-byte integers,
                        each in the range 0 through 65535. "))
            (entry (% (heading (code "GL_INT")))
                   (para (var "lists")
                         " is treated as an array of signed four-byte integers. "))
            (entry (% (heading (code "GL_UNSIGNED_INT")))
                   (para (var "lists")
                         " is treated as an array of unsigned four-byte integers. "))
            (entry (% (heading (code "GL_FLOAT")))
                   (para (var "lists")
                         " is treated as an array of four-byte floating-point values. "))
            (entry (% (heading (code "GL_2_BYTES")))
                   (para (var "lists")
                         " is treated as an array of unsigned bytes.
                        Each pair of bytes specifies a single display-list name.
                        The value of the pair is computed as 256 times the unsigned value
                        of the first byte plus the unsigned value of the second byte. "))
            (entry (% (heading (code "GL_3_BYTES")))
                   (para (var "lists")
                         " is treated as an array of unsigned bytes.
                        Each triplet of bytes specifies a single display-list name.
                        The value of the triplet is computed as 65536 times the unsigned value
                        of the first byte,
                        plus 256 times the unsigned value of the second byte,
                        plus the unsigned value of the third byte. "))
            (entry (% (heading (code "GL_4_BYTES")))
                   (para (var "lists")
                         " is treated as an array of unsigned bytes.
                        Each quadruplet of bytes specifies a single display-list name.
                        The value of the quadruplet is computed as 16777216 times the unsigned value
                        of the first byte,
                        plus 65536 times the unsigned value of the second byte,
                        plus 256 times the unsigned value of the third byte,
                        plus the unsigned value of the fourth byte. ")))
     (para "
The list of display-list names is not null-terminated.
            Rather, "
           (var "n")
           " specifies how many names are to be taken from "
           (var "lists")
           ". ")
     (para "
An additional level of indirection is made available with the "
           (code "glListBase")
           " command,
            which specifies an unsigned offset that is added to each display-list
            name specified in "
           (var "lists")
           " before that display list is executed. ")
     (para (code "glCallLists")
           " can appear inside a display list.
            To avoid the possibility of infinite recursion resulting from display lists
            calling one another,
            a limit is placed on the nesting level of display
            lists during display-list execution.
            This limit must be at least 64, and it depends on the implementation. ")
     (para "
GL state is not saved and restored across a call to "
           (code "glCallLists")
           ".
            Thus,
            changes made to GL state during the execution of the display lists
            remain after execution is completed.
            Use "
           (code "glPushAttrib")
           ", "
           (code "glPopAttrib")
           ", "
           (code "glPushMatrix")
           ",
            and "
           (code "glPopMatrix")
           " to preserve GL state across "
           (code "glCallLists")
           " calls. ")
     (heading "Errors")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "n")
           " is negative. ")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "type")
           " is not one of "
           (code "GL_BYTE")
           ", "
           (code "GL_UNSIGNED_BYTE")
           ", "
           (code "GL_SHORT")
           ", "
           (code "GL_UNSIGNED_SHORT")
           ", "
           (code "GL_INT")
           ", "
           (code "GL_UNSIGNED_INT")
           ", "
           (code "GL_FLOAT")
           ", "
           (code "GL_2_BYTES")
           ", "
           (code "GL_3_BYTES")
           ", "
           (code "GL_4_BYTES")
           ". ")))

(define-gl-procedure
  glCallList
  "glCallList"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glCallList"))
      (paramdef "GLuint " (parameter "list"))))
  '(*fragment*
     (heading "execute a display list")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "list")))
                   (para "
Specifies the integer name of the display list to be executed. ")))
     (heading "Description")
     (para (code "glCallList")
           " causes the named display list to be executed.
            The commands saved in the display list are executed in order,
            just as if they were called without using a display list.
            If "
           (var "list")
           " has not been defined as a display list, "
           (code "glCallList")
           " is ignored. ")
     (para (code "glCallList")
           " can appear inside a display list.
            To avoid the possibility of infinite recursion resulting from display lists
            calling one another,
            a limit is placed on the nesting level of display
            lists during display-list execution.
            This limit is at least 64, and it depends on the implementation. ")
     (para "
GL state is not saved and restored across a call to "
           (code "glCallList")
           ".
            Thus,
            changes made to GL state during the execution of a display list
            remain after execution of the display list is completed.
            Use "
           (code "glPushAttrib")
           ", "
           (code "glPopAttrib")
           ", "
           (code "glPushMatrix")
           ",
            and "
           (code "glPopMatrix")
           " to preserve GL state across "
           (code "glCallList")
           " calls. ")))

(define-gl-procedure
  glClearAccum
  "glClearAccum"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glClearAccum"))
      (paramdef "GLfloat " (parameter "red"))
      (paramdef "GLfloat " (parameter "green"))
      (paramdef "GLfloat " (parameter "blue"))
      (paramdef "GLfloat " (parameter "alpha"))))
  '(*fragment*
     (heading
       "specify clear values for the accumulation buffer")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "red")))
                   (itemx (var "green"))
                   (itemx (var "blue"))
                   (itemx (var "alpha"))
                   (para "
Specify the red, green, blue, and alpha values used when the
                    accumulation buffer is cleared.
                    The initial values are all 0. ")))
     (heading "Description")
     (para (code "glClearAccum")
           " specifies the red, green, blue, and alpha values used by "
           (code "glClear")
           "
to clear the accumulation buffer. ")
     (para "
Values specified by "
           (code "glClearAccum")
           " are clamped to the
            range "
           (math "[" "-1" "," "1" "]")
           ". ")
     (heading "Errors")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glClearAccum")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glClearColor
  "glClearColor"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glClearColor"))
      (paramdef "GLclampf " (parameter "red"))
      (paramdef "GLclampf " (parameter "green"))
      (paramdef "GLclampf " (parameter "blue"))
      (paramdef "GLclampf " (parameter "alpha"))))
  '(*fragment*
     (heading
       "specify clear values for the color buffers")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "red")))
                   (itemx (var "green"))
                   (itemx (var "blue"))
                   (itemx (var "alpha"))
                   (para "
Specify the red, green, blue, and alpha values used when the
                    color buffers are cleared.
                    The initial values are all 0. ")))
     (heading "Description")
     (para (code "glClearColor")
           " specifies the red,
            green,
            blue,
            and alpha values used by "
           (code "glClear")
           " to clear the color buffers.
            Values specified by "
           (code "glClearColor")
           " are clamped to the range "
           (math "[" "0" "," "1" "]")
           ". ")
     (heading "Errors")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glClearColor")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glClearDepth
  "glClearDepth"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glClearDepth"))
      (paramdef "GLclampd " (parameter "depth"))))
  '(*fragment*
     (heading
       "specify the clear value for the depth buffer")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "depth")))
                   (para "
Specifies the depth value used when the depth buffer is cleared. The
                    initial value is 1. ")))
     (heading "Description")
     (para (code "glClearDepth")
           " specifies the depth value used by "
           (code "glClear")
           " to clear the depth buffer.
            Values specified by "
           (code "glClearDepth")
           " are clamped to the range "
           (math "[" "0" "," "1" "]")
           ". ")
     (heading "Errors")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glClearDepth")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glClearIndex
  "glClearIndex"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glClearIndex"))
      (paramdef "GLfloat " (parameter "c"))))
  '(*fragment*
     (heading
       "specify the clear value for the color index buffers")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "c")))
                   (para "
Specifies the index used when the color index buffers are cleared.
                    The initial value is 0. ")))
     (heading "Description")
     (para (code "glClearIndex")
           " specifies the index used by "
           (code "glClear")
           "
to clear the color index buffers. "
           (var "c")
           " is not clamped.
            Rather, "
           (var "c")
           " is converted to a fixed-point value with unspecified precision
            to the right of the binary point.
            The integer part of this value is then masked with "
           (math "2" "^" (var "m") "-" "1")
           ",
            where "
           (math (var "m"))
           "
is the number of bits in a color index stored in the frame buffer. ")
     (heading "Errors")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glClearIndex")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glClearStencil
  "glClearStencil"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glClearStencil"))
      (paramdef "GLint " (parameter "s"))))
  '(*fragment*
     (heading
       "specify the clear value for the stencil buffer")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "s")))
                   (para "
Specifies the index used when the stencil buffer is cleared.
                    The initial value is 0. ")))
     (heading "Description")
     (para (code "glClearStencil")
           " specifies the index used by "
           (code "glClear")
           " to clear the stencil buffer. "
           (var "s")
           " is masked with "
           (math "2" "^" (var "m") "-" "1")
           ",
            where "
           (math (var "m"))
           "
is the number of bits in the stencil buffer. ")
     (heading "Errors")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glClearStencil")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glClear
  "glClear"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glClear"))
      (paramdef "GLbitfield " (parameter "mask"))))
  '(*fragment*
     (heading "clear buffers to preset values")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "mask")))
                   (para "
Bitwise OR of masks that indicate the buffers to be cleared.
                    The four masks are "
                         (code "GL_COLOR_BUFFER_BIT")
                         ", "
                         (code "GL_DEPTH_BUFFER_BIT")
                         ", "
                         (code "GL_ACCUM_BUFFER_BIT")
                         ", and "
                         (code "GL_STENCIL_BUFFER_BIT")
                         ". ")))
     (heading "Description")
     (para (code "glClear")
           " sets the bitplane area of the window to values previously selected
            by "
           (code "glClearColor")
           ", "
           (code "glClearIndex")
           ", "
           (code "glClearDepth")
           ", "
           (code "glClearStencil")
           ", and "
           (code "glClearAccum")
           ".
            Multiple color buffers can be cleared simultaneously by selecting
            more than one buffer at a time using "
           (code "glDrawBuffer")
           ". ")
     (para "
The pixel ownership test,
            the scissor test,
            dithering, and the buffer writemasks affect the operation of "
           (code "glClear")
           ".
            The scissor box bounds the cleared region.
            Alpha function,
            blend function,
            logical operation,
            stenciling,
            texture mapping,
            and depth-buffering are ignored by "
           (code "glClear")
           ". ")
     (para (code "glClear")
           " takes a single argument that is the bitwise OR of several
            values indicating which buffer is to be cleared. ")
     (para "
The values are as follows: ")
     (table (% (formatter (asis)))
            (entry (% (heading (code "GL_COLOR_BUFFER_BIT")))
                   (para "
Indicates the buffers currently enabled for color
                        writing. "))
            (entry (% (heading (code "GL_DEPTH_BUFFER_BIT")))
                   (para "
Indicates the depth buffer. "))
            (entry (% (heading (code "GL_ACCUM_BUFFER_BIT")))
                   (para "
Indicates the accumulation buffer. "))
            (entry (% (heading (code "GL_STENCIL_BUFFER_BIT")))
                   (para "
Indicates the stencil buffer. ")))
     (para "
The value to which each buffer is cleared depends on the setting of the
            clear value for that buffer. ")
     (heading "Errors")
     (para (code "GL_INVALID_VALUE")
           " is generated if any bit other than the four defined
            bits is set in "
           (var "mask")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glClear")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glClientActiveTexture
  "glClientActiveTexture"
  (funcsynopsis
    (funcprototype
      (funcdef
        "void "
        (function "glClientActiveTexture"))
      (paramdef "GLenum " (parameter "texture"))))
  '(*fragment*
     (heading "select active texture unit")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "texture")))
                   (para "
Specifies which texture unit to make active. The number
                    of texture units is implementation dependent, but must be at least
                    two. "
                         (var "texture")
                         " must be one of "
                         (code "GL_TEXTURE")
                         (math (var "i"))
                         ",
                    where i ranges from 0 to the value of "
                         (code "GL_MAX_TEXTURE_COORDS")
                         " - 1, which is an
                    implementation-dependent value.  The initial value is "
                         (code "GL_TEXTURE0")
                         ". ")))
     (heading "Description")
     (para (code "glClientActiveTexture")
           " selects the vertex array client state parameters to be modified by "
           (code "glTexCoordPointer")
           ", and enabled or disabled with "
           (code "glEnableClientState")
           " or "
           (code "glDisableClientState")
           ", respectively,
            when called with a parameter of "
           (code "GL_TEXTURE_COORD_ARRAY")
           ". ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "texture")
           " is not one of "
           (code "GL_TEXTURE")
           (math (var "i"))
           ",
            where
            i ranges from 0 to the value of "
           (code "GL_MAX_TEXTURE_COORDS")
           " - 1. ")))

(define-gl-procedure
  glClipPlane
  "glClipPlane"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glClipPlane"))
      (paramdef "GLenum " (parameter "plane"))
      (paramdef
        "const GLdouble * "
        (parameter "equation"))))
  '(*fragment*
     (heading
       "specify a plane against which all geometry is clipped")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "plane")))
                   (para "
Specifies which clipping plane is being positioned.
                    Symbolic names of the form "
                         (code "GL_CLIP_PLANE")
                         (var "i")
                         ",
                    where "
                         (var "i")
                         " is an integer between 0 and "
                         (code "GL_MAX_CLIP_PLANES")
                         (math "-1")
                         ",
                    are accepted. "))
            (entry (% (heading (var "equation")))
                   (para "
Specifies the address of an array of four double-precision floating-point values.
                    These values are interpreted as a plane equation. ")))
     (heading "Description")
     (para "
Geometry is always clipped against the boundaries of a six-plane frustum
            in "
           (var "x")
           ", "
           (var "y")
           ", and "
           (var "z")
           ". "
           (code "glClipPlane")
           " allows the specification of additional planes,
            not necessarily perpendicular to the "
           (var "x")
           ", "
           (var "y")
           ", or "
           (var "z")
           " axis,
            against which all geometry is clipped.
            To determine the maximum number of additional clipping planes, call "
           (code "glGetIntegerv")
           " with argument "
           (code "GL_MAX_CLIP_PLANES")
           ". All
            implementations support at least six such clipping planes.
            Because the resulting clipping region is the intersection
            of the defined half-spaces,
            it is always convex. ")
     (para (code "glClipPlane")
           " specifies a half-space using a four-component plane equation.
            When "
           (code "glClipPlane")
           " is called, "
           (var "equation")
           " is transformed by the inverse of the modelview matrix
            and stored in the resulting eye coordinates.
            Subsequent changes to the modelview matrix have no effect on the
            stored plane-equation components.
            If the dot product of the eye coordinates of a vertex with the
            stored plane equation components is positive or zero,
            the vertex is "
           (var "in")
           " with respect to that clipping plane.
            Otherwise, it is "
           (var "out")
           ". ")
     (para "
To enable and disable clipping planes, call "
           (code "glEnable")
           " and "
           (code "glDisable")
           " with the argument "
           (code "GL_CLIP_PLANE")
           (var "i")
           ",
            where "
           (var "i")
           " is the plane number. ")
     (para "
All clipping planes are initially defined as (0, 0, 0, 0) in eye coordinates
            and are
            disabled. ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "plane")
           " is not an accepted value. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glClipPlane")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glColorMask
  "glColorMask"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glColorMask"))
      (paramdef "GLboolean " (parameter "red"))
      (paramdef "GLboolean " (parameter "green"))
      (paramdef "GLboolean " (parameter "blue"))
      (paramdef "GLboolean " (parameter "alpha"))))
  '(*fragment*
     (heading
       "enable and disable writing of frame buffer color components")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "red")))
                   (itemx (var "green"))
                   (itemx (var "blue"))
                   (itemx (var "alpha"))
                   (para "
Specify whether red, green, blue, and alpha can or cannot be written
                    into the frame buffer.
                    The initial values are all "
                         (code "GL_TRUE")
                         ",
                    indicating that the color components can be written. ")))
     (heading "Description")
     (para (code "glColorMask")
           " specifies whether the individual color components in the frame buffer
            can or cannot be written.
            If "
           (var "red")
           " is "
           (code "GL_FALSE")
           ",
            for example,
            no change is made to the red component of any pixel in any of the
            color buffers,
            regardless of the drawing operation attempted. ")
     (para "
Changes to individual bits of components cannot be controlled.
            Rather,
            changes are either enabled or disabled for entire color components. ")
     (heading "Errors")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glColorMask")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glColorMaterial
  "glColorMaterial"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glColorMaterial"))
      (paramdef "GLenum " (parameter "face"))
      (paramdef "GLenum " (parameter "mode"))))
  '(*fragment*
     (heading
       "cause a material color to track the current color")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "face")))
                   (para "
Specifies whether front,
                    back,
                    or both front and back material parameters should track the current color.
                    Accepted values are "
                         (code "GL_FRONT")
                         ", "
                         (code "GL_BACK")
                         ",
                    and "
                         (code "GL_FRONT_AND_BACK")
                         ".
                    The initial value is "
                         (code "GL_FRONT_AND_BACK")
                         ". "))
            (entry (% (heading (var "mode")))
                   (para "
Specifies which of several material parameters track the current color.
                    Accepted values are "
                         (code "GL_EMISSION")
                         ", "
                         (code "GL_AMBIENT")
                         ", "
                         (code "GL_DIFFUSE")
                         ", "
                         (code "GL_SPECULAR")
                         ",
                    and "
                         (code "GL_AMBIENT_AND_DIFFUSE")
                         ".
                    The initial value is "
                         (code "GL_AMBIENT_AND_DIFFUSE")
                         ". ")))
     (heading "Description")
     (para (code "glColorMaterial")
           " specifies which material parameters track the current color.
            When "
           (code "GL_COLOR_MATERIAL")
           " is enabled,
            the material parameter or parameters specified by "
           (var "mode")
           ",
            of the material or materials specified by "
           (var "face")
           ",
            track the current color at all times. ")
     (para "
To enable and disable "
           (code "GL_COLOR_MATERIAL")
           ", call "
           (code "glEnable")
           " and "
           (code "glDisable")
           " with argument "
           (code "GL_COLOR_MATERIAL")
           ". "
           (code "GL_COLOR_MATERIAL")
           " is initially disabled. ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "face")
           " or "
           (var "mode")
           " is not an
            accepted value. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glColorMaterial")
           " is executed between
            the execution of "
           (code "glBegin")
           " and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glColorPointer
  "glColorPointer"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glColorPointer"))
      (paramdef "GLint " (parameter "size"))
      (paramdef "GLenum " (parameter "type"))
      (paramdef "GLsizei " (parameter "stride"))
      (paramdef
        "const GLvoid * "
        (parameter "pointer"))))
  '(*fragment*
     (heading "define an array of colors")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "size")))
                   (para "
Specifies the number of components per color. Must be 3 or 4.
                    The initial value is 4. "))
            (entry (% (heading (var "type")))
                   (para "
Specifies the data type of each color component in the array.
                    Symbolic constants "
                         (code "GL_BYTE")
                         ", "
                         (code "GL_UNSIGNED_BYTE")
                         ", "
                         (code "GL_SHORT")
                         ", "
                         (code "GL_UNSIGNED_SHORT")
                         ", "
                         (code "GL_INT")
                         ", "
                         (code "GL_UNSIGNED_INT")
                         ", "
                         (code "GL_FLOAT")
                         ",
                    and "
                         (code "GL_DOUBLE")
                         "
are accepted.
                    The initial value is "
                         (code "GL_FLOAT")
                         ". "))
            (entry (% (heading (var "stride")))
                   (para "
Specifies the byte offset between consecutive colors.
                    If "
                         (var "stride")
                         " is 0, the colors are understood to be
                    tightly packed in the array. The initial value is 0. "))
            (entry (% (heading (var "pointer")))
                   (para "
Specifies a pointer to the first component of the first color element
                    in the array. The initial value is 0. ")))
     (heading "Description")
     (para (code "glColorPointer")
           " specifies the location and data format of an array of color components
            to use when rendering. "
           (var "size")
           " specifies the number of components per color, and must be 3 or 4. "
           (var "type")
           " specifies the data type of each color component, and "
           (var "stride")
           "
specifies the byte stride from one color to the next, allowing vertices and
            attributes to be packed into a single array or stored in separate arrays.
            (Single-array storage may be more efficient on some implementations;
            see "
           (code "glInterleavedArrays")
           ".) ")
     (para "
If a non-zero named buffer object is bound to the "
           (code "GL_ARRAY_BUFFER")
           " target 
            (see "
           (code "glBindBuffer")
           ") while a color array is
            specified, "
           (var "pointer")
           " is treated as a byte offset into the buffer object's data store.
            Also, the buffer object binding ("
           (code "GL_ARRAY_BUFFER_BINDING")
           ") is saved as color vertex array
            client-side state ("
           (code "GL_COLOR_ARRAY_BUFFER_BINDING")
           "). ")
     (para "
When a color array is specified, "
           (var "size")
           ", "
           (var "type")
           ", "
           (var "stride")
           ", and "
           (var "pointer")
           " are saved as client-side
            state, in addition to the current vertex array buffer object binding. ")
     (para "
To enable and disable the color array, call "
           (code "glEnableClientState")
           " and "
           (code "glDisableClientState")
           " with the argument "
           (code "GL_COLOR_ARRAY")
           ". If
            enabled, the color array is used
            when "
           (code "glDrawArrays")
           ", "
           (code "glMultiDrawArrays")
           ", "
           (code "glDrawElements")
           ", "
           (code "glMultiDrawElements")
           ", "
           (code "glDrawRangeElements")
           ", or "
           (code "glArrayElement")
           " is called. ")
     (heading "Errors")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "size")
           " is not 3 or 4. ")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "type")
           " is not an accepted value. ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "stride")
           " is negative. ")))

(define-gl-procedure
  glColorSubTable
  "glColorSubTable"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glColorSubTable"))
      (paramdef "GLenum " (parameter "target"))
      (paramdef "GLsizei " (parameter "start"))
      (paramdef "GLsizei " (parameter "count"))
      (paramdef "GLenum " (parameter "format"))
      (paramdef "GLenum " (parameter "type"))
      (paramdef "const GLvoid * " (parameter "data"))))
  '(*fragment*
     (heading "respecify a portion of a color table")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "target")))
                   (para "
Must be one of "
                         (code "GL_COLOR_TABLE")
                         ", "
                         (code "GL_POST_CONVOLUTION_COLOR_TABLE")
                         ", or "
                         (code "GL_POST_COLOR_MATRIX_COLOR_TABLE")
                         ". "))
            (entry (% (heading (var "start")))
                   (para "
The starting index of the portion of the color table to be replaced. "))
            (entry (% (heading (var "count")))
                   (para "
The number of table entries to replace. "))
            (entry (% (heading (var "format")))
                   (para "
The format of the pixel data in "
                         (var "data")
                         ".
                    The allowable values are "
                         (code "GL_RED")
                         ", "
                         (code "GL_GREEN")
                         ", "
                         (code "GL_BLUE")
                         ", "
                         (code "GL_ALPHA")
                         ", "
                         (code "GL_LUMINANCE")
                         ", "
                         (code "GL_LUMINANCE_ALPHA")
                         ", "
                         (code "GL_RGB")
                         ", "
                         (code "GL_BGR")
                         ", "
                         (code "GL_RGBA")
                         ", and "
                         (code "GL_BGRA")
                         ". "))
            (entry (% (heading (var "type")))
                   (para "
The type of the pixel data in "
                         (var "data")
                         ".
                    The allowable values are "
                         (code "GL_UNSIGNED_BYTE")
                         ", "
                         (code "GL_BYTE")
                         ", "
                         (code "GL_UNSIGNED_SHORT")
                         ", "
                         (code "GL_SHORT")
                         ", "
                         (code "GL_UNSIGNED_INT")
                         ", "
                         (code "GL_INT")
                         ", "
                         (code "GL_FLOAT")
                         ", "
                         (code "GL_UNSIGNED_BYTE_3_3_2")
                         ", "
                         (code "GL_UNSIGNED_BYTE_2_3_3_REV")
                         ", "
                         (code "GL_UNSIGNED_SHORT_5_6_5")
                         ", "
                         (code "GL_UNSIGNED_SHORT_5_6_5_REV")
                         ", "
                         (code "GL_UNSIGNED_SHORT_4_4_4_4")
                         ", "
                         (code "GL_UNSIGNED_SHORT_4_4_4_4_REV")
                         ", "
                         (code "GL_UNSIGNED_SHORT_5_5_5_1")
                         ", "
                         (code "GL_UNSIGNED_SHORT_1_5_5_5_REV")
                         ", "
                         (code "GL_UNSIGNED_INT_8_8_8_8")
                         ", "
                         (code "GL_UNSIGNED_INT_8_8_8_8_REV")
                         ", "
                         (code "GL_UNSIGNED_INT_10_10_10_2")
                         ", and "
                         (code "GL_UNSIGNED_INT_2_10_10_10_REV")
                         ". "))
            (entry (% (heading (var "data")))
                   (para "
Pointer to a one-dimensional array of pixel data that is processed to
                    replace the specified region of the color table. ")))
     (heading "Description")
     (para (code "glColorSubTable")
           " is used to respecify a contiguous portion of a color table previously
            defined using "
           (code "glColorTable")
           ".  The pixels referenced by "
           (var "data")
           " replace the
            portion of the existing table from indices "
           (var "start")
           " to "
           (math (var "start") "+" (var "count") "-" "1")
           ",
            inclusive.  This region may not include any
            entries outside the range of the color table as it was originally specified.
            It is not an error to specify a subtexture with width of 0, but such a
            specification has no effect. ")
     (para "
If a non-zero named buffer object is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target 
            (see "
           (code "glBindBuffer")
           ") while a portion of a color table is
            respecified, "
           (var "data")
           " is treated as a byte offset into the buffer object's data store. ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "target")
           " is not one of the allowable
            values. ")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "format")
           " is not one of the allowable
            values. ")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "type")
           " is not one of the allowable
            values. ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (math (var "start")
                 "+"
                 (var "count")
                 ">"
                 (var "width"))
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target and the buffer object's data store is currently mapped. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target and the data would be unpacked from the buffer 
            object such that the memory reads required would exceed the data store size. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target and "
           (var "data")
           " is not evenly divisible 
            into the number of bytes needed to store in memory a datum indicated by "
           (var "type")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glColorSubTable")
           " is executed
            between the execution of "
           (code "glBegin")
           " and the corresponding
            execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glColorTableParameter
  "glColorTableParameter"
  (funcsynopsis
    (funcprototype
      (funcdef
        "void "
        (function "glColorTableParameterfv"))
      (paramdef "GLenum " (parameter "target"))
      (paramdef "GLenum " (parameter "pname"))
      (paramdef
        "const GLfloat * "
        (parameter "params"))))
  '(*fragment*
     (heading "set color lookup table parameters")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "target")))
                   (para "
The target color table.
                    Must be "
                         (code "GL_COLOR_TABLE")
                         ", "
                         (code "GL_POST_CONVOLUTION_COLOR_TABLE")
                         ", or "
                         (code "GL_POST_COLOR_MATRIX_COLOR_TABLE")
                         ". "))
            (entry (% (heading (var "pname")))
                   (para "
The symbolic name of a texture color lookup table parameter.
                    Must be one of "
                         (code "GL_COLOR_TABLE_SCALE")
                         " or "
                         (code "GL_COLOR_TABLE_BIAS")
                         ". "))
            (entry (% (heading (var "params")))
                   (para "
A pointer to an array where the values of the parameters are stored. ")))
     (heading "Description")
     (para (code "glColorTableParameter")
           " is used to specify the scale factors and bias terms applied to
            color components when they are loaded into a color table. "
           (var "target")
           "
indicates which color table the scale and bias terms apply to; it
            must be set to "
           (code "GL_COLOR_TABLE")
           ", "
           (code "GL_POST_CONVOLUTION_COLOR_TABLE")
           ", or "
           (code "GL_POST_COLOR_MATRIX_COLOR_TABLE")
           ". ")
     (para (var "pname")
           " must be "
           (code "GL_COLOR_TABLE_SCALE")
           " to set the
            scale factors.
            In this case, "
           (var "params")
           " points to an array of four values, which are
            the scale factors for red, green, blue, and alpha, in that order. ")
     (para (var "pname")
           " must be "
           (code "GL_COLOR_TABLE_BIAS")
           " to set the
            bias terms. In this case, "
           (var "params")
           " points to an array of four values, which are the bias
            terms for red, green, blue, and alpha, in that order. ")
     (para "
The color tables themselves are specified by
            calling "
           (code "glColorTable")
           ". ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "target")
           " or "
           (var "pname")
           " is not
            an acceptable value. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glColorTableParameter")
           " is executed
            between the execution of "
           (code "glBegin")
           " and the corresponding
            execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glColorTable
  "glColorTable"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glColorTable"))
      (paramdef "GLenum " (parameter "target"))
      (paramdef "GLenum " (parameter "internalformat"))
      (paramdef "GLsizei " (parameter "width"))
      (paramdef "GLenum " (parameter "format"))
      (paramdef "GLenum " (parameter "type"))
      (paramdef "const GLvoid * " (parameter "data"))))
  '(*fragment*
     (heading "define a color lookup table")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "target")))
                   (para "
Must be one of "
                         (code "GL_COLOR_TABLE")
                         ", "
                         (code "GL_POST_CONVOLUTION_COLOR_TABLE")
                         ", "
                         (code "GL_POST_COLOR_MATRIX_COLOR_TABLE")
                         ", "
                         (code "GL_PROXY_COLOR_TABLE")
                         ", "
                         (code "GL_PROXY_POST_CONVOLUTION_COLOR_TABLE")
                         ",
                    or "
                         (code "GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE")
                         ". "))
            (entry (% (heading (var "internalformat")))
                   (para "
The internal format of the color table.
                    The allowable values are "
                         (code "GL_ALPHA")
                         ", "
                         (code "GL_ALPHA4")
                         ", "
                         (code "GL_ALPHA8")
                         ", "
                         (code "GL_ALPHA12")
                         ", "
                         (code "GL_ALPHA16")
                         ", "
                         (code "GL_LUMINANCE")
                         ", "
                         (code "GL_LUMINANCE4")
                         ", "
                         (code "GL_LUMINANCE8")
                         ", "
                         (code "GL_LUMINANCE12")
                         ", "
                         (code "GL_LUMINANCE16")
                         ", "
                         (code "GL_LUMINANCE_ALPHA")
                         ", "
                         (code "GL_LUMINANCE4_ALPHA4")
                         ", "
                         (code "GL_LUMINANCE6_ALPHA2")
                         ", "
                         (code "GL_LUMINANCE8_ALPHA8")
                         ", "
                         (code "GL_LUMINANCE12_ALPHA4")
                         ", "
                         (code "GL_LUMINANCE12_ALPHA12")
                         ", "
                         (code "GL_LUMINANCE16_ALPHA16")
                         ", "
                         (code "GL_INTENSITY")
                         ", "
                         (code "GL_INTENSITY4")
                         ", "
                         (code "GL_INTENSITY8")
                         ", "
                         (code "GL_INTENSITY12")
                         ", "
                         (code "GL_INTENSITY16")
                         ", "
                         (code "GL_R3_G3_B2")
                         ", "
                         (code "GL_RGB")
                         ", "
                         (code "GL_RGB4")
                         ", "
                         (code "GL_RGB5")
                         ", "
                         (code "GL_RGB8")
                         ", "
                         (code "GL_RGB10")
                         ", "
                         (code "GL_RGB12")
                         ", "
                         (code "GL_RGB16")
                         ", "
                         (code "GL_RGBA")
                         ", "
                         (code "GL_RGBA2")
                         ", "
                         (code "GL_RGBA4")
                         ", "
                         (code "GL_RGB5_A1")
                         ", "
                         (code "GL_RGBA8")
                         ", "
                         (code "GL_RGB10_A2")
                         ", "
                         (code "GL_RGBA12")
                         ", and "
                         (code "GL_RGBA16")
                         ". "))
            (entry (% (heading (var "width")))
                   (para "
The number of entries in the color lookup table specified by "
                         (var "data")
                         ". "))
            (entry (% (heading (var "format")))
                   (para "
The format of the pixel data in "
                         (var "data")
                         ".
                    The allowable values are "
                         (code "GL_RED")
                         ", "
                         (code "GL_GREEN")
                         ", "
                         (code "GL_BLUE")
                         ", "
                         (code "GL_ALPHA")
                         ", "
                         (code "GL_LUMINANCE")
                         ", "
                         (code "GL_LUMINANCE_ALPHA")
                         ", "
                         (code "GL_RGB")
                         ", "
                         (code "GL_BGR")
                         ", "
                         (code "GL_RGBA")
                         ", and "
                         (code "GL_BGRA")
                         ". "))
            (entry (% (heading (var "type")))
                   (para "
The type of the pixel data in "
                         (var "data")
                         ".
                    The allowable values are "
                         (code "GL_UNSIGNED_BYTE")
                         ", "
                         (code "GL_BYTE")
                         ", "
                         (code "GL_UNSIGNED_SHORT")
                         ", "
                         (code "GL_SHORT")
                         ", "
                         (code "GL_UNSIGNED_INT")
                         ", "
                         (code "GL_INT")
                         ", "
                         (code "GL_FLOAT")
                         ", "
                         (code "GL_UNSIGNED_BYTE_3_3_2")
                         ", "
                         (code "GL_UNSIGNED_BYTE_2_3_3_REV")
                         ", "
                         (code "GL_UNSIGNED_SHORT_5_6_5")
                         ", "
                         (code "GL_UNSIGNED_SHORT_5_6_5_REV")
                         ", "
                         (code "GL_UNSIGNED_SHORT_4_4_4_4")
                         ", "
                         (code "GL_UNSIGNED_SHORT_4_4_4_4_REV")
                         ", "
                         (code "GL_UNSIGNED_SHORT_5_5_5_1")
                         ", "
                         (code "GL_UNSIGNED_SHORT_1_5_5_5_REV")
                         ", "
                         (code "GL_UNSIGNED_INT_8_8_8_8")
                         ", "
                         (code "GL_UNSIGNED_INT_8_8_8_8_REV")
                         ", "
                         (code "GL_UNSIGNED_INT_10_10_10_2")
                         ", and "
                         (code "GL_UNSIGNED_INT_2_10_10_10_REV")
                         ". "))
            (entry (% (heading (var "data")))
                   (para "
Pointer to a one-dimensional array of pixel data that is processed to
                    build the color table. ")))
     (heading "Description")
     (para (code "glColorTable")
           " may be used in two ways:
            to test the actual size and color resolution of a lookup table
            given a particular set of parameters,
            or to load the contents of a color lookup
            table.
            Use the targets "
           (code "GL_PROXY_*")
           " for the first case
            and the other targets for the second case. ")
     (para "
If a non-zero named buffer object is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target 
            (see "
           (code "glBindBuffer")
           ") while a color table is
            specified, "
           (var "data")
           " is treated as a byte offset into the buffer object's data store. ")
     (para "
If "
           (var "target")
           " is "
           (code "GL_COLOR_TABLE")
           ", "
           (code "GL_POST_CONVOLUTION_COLOR_TABLE")
           ",
            or "
           (code "GL_POST_COLOR_MATRIX_COLOR_TABLE")
           ", "
           (code "glColorTable")
           " builds a color lookup table from an array of pixels.
            The pixel array specified by "
           (var "width")
           ", "
           (var "format")
           ", "
           (var "type")
           ", and "
           (var "data")
           "
is extracted from memory and
            processed just as if "
           (code "glDrawPixels")
           " were called, but processing
            stops after the final expansion to RGBA is completed. ")
     (para "
The four scale parameters and the four bias parameters that are defined
            for the table are then used to scale and bias the R, G, B, and A components
            of each pixel.
            (Use "
           (code "glColorTableParameter")
           " to set these scale and bias
            parameters.) ")
     (para "
Next, the R, G, B, and A values are clamped to the range "
           (math "[" "0" "," "1" "]")
           ".
            Each pixel is then converted to the internal format specified by "
           (var "internalformat")
           ".
            This conversion simply maps the component values of the pixel (R, G, B,
            and A) to the values included in the internal format (red, green, blue,
            alpha, luminance, and intensity).  The mapping is as follows: ")
     (para)
     (table (% (formatter (asis)))
            (entry (% (heading (strong "Internal Format")))
                   (para (strong "Red")
                         ", "
                         (strong "Green")
                         ", "
                         (strong "Blue")
                         ", "
                         (strong "Alpha")
                         ", "
                         (strong "Luminance")
                         ", "
                         (strong "Intensity")))
            (entry (% (heading (code "GL_ALPHA")))
                   (para ", " ", " ", " "
A " ", " ", "))
            (entry (% (heading (code "GL_LUMINANCE")))
                   (para ", " ", " ", " ", " "
R " ", "))
            (entry (% (heading (code "GL_LUMINANCE_ALPHA")))
                   (para ", " ", " ", " "
A " ", " "
R " ", "))
            (entry (% (heading (code "GL_INTENSITY")))
                   (para ", " ", " ", " ", " ", " "
R "))
            (entry (% (heading (code "GL_RGB")))
                   (para "
R " ", " "
G " ", " "
B " ", " ", " ", "))
            (entry (% (heading (code "GL_RGBA")))
                   (para "
R "
                         ", "
                         "
G "
                         ", "
                         "
B "
                         ", "
                         "
A "
                         ", "
                         ", ")))
     (para "
Finally, the red, green, blue, alpha, luminance, and/or intensity components of
            the resulting pixels are stored in the color table.
            They form a one-dimensional table with indices in the range "
           (math "[" "0" "," (var "width") "-" "1" "]")
           ". ")
     (para "
If "
           (var "target")
           " is "
           (code "GL_PROXY_*")
           ", "
           (code "glColorTable")
           " recomputes and stores the values of the proxy color table's state
            variables "
           (code "GL_COLOR_TABLE_FORMAT")
           ", "
           (code "GL_COLOR_TABLE_WIDTH")
           ", "
           (code "GL_COLOR_TABLE_RED_SIZE")
           ", "
           (code "GL_COLOR_TABLE_GREEN_SIZE")
           ", "
           (code "GL_COLOR_TABLE_BLUE_SIZE")
           ", "
           (code "GL_COLOR_TABLE_ALPHA_SIZE")
           ", "
           (code "GL_COLOR_TABLE_LUMINANCE_SIZE")
           ", and "
           (code "GL_COLOR_TABLE_INTENSITY_SIZE")
           ".
            There is no effect on the image or state of any actual color table.
            If the specified color table is too large to be supported, then all the
            proxy state variables listed above are set to zero.
            Otherwise, the color table could be supported by "
           (code "glColorTable")
           "
using the corresponding non-proxy target,
            and the proxy state variables are set as if that target were being defined. ")
     (para "
The proxy state variables can be retrieved by calling "
           (code "glGetColorTableParameter")
           " with a target of "
           (code "GL_PROXY_*")
           ".
            This allows the application to decide if a particular "
           (code "glColorTable")
           "
command would succeed, and to determine what the resulting color table
            attributes would be. ")
     (para "
If a color table is enabled, and its width is non-zero, then its
            contents are used to replace a subset of the components of each RGBA
            pixel group, based on the internal format of the table. ")
     (para "
Each pixel group has color components (R, G, B, A)
            that are in the range "
           (math "[" "0.0" "," "1.0" "]")
           ".
            The color components are rescaled to
            the size of the color lookup table to form an index.
            Then a subset of the components based on the internal format of the table are
            replaced by the table entry selected by that index.
            If the color components and contents of the table are represented as follows: ")
     (para)
     (table (% (formatter (asis)))
            (entry (% (heading (strong "Representation")))
                   (para (strong "Meaning")))
            (entry (% (heading (code "r")))
                   (para "
Table index computed from " (code "R")))
            (entry (% (heading (code "g")))
                   (para "
Table index computed from " (code "G")))
            (entry (% (heading (code "b")))
                   (para "
Table index computed from " (code "B")))
            (entry (% (heading (code "a")))
                   (para "
Table index computed from " (code "A")))
            (entry (% (heading (code "L[i]")))
                   (para "
Luminance value at table index "
                         (code "i")))
            (entry (% (heading (code "I[i]")))
                   (para "
Intensity value at table index "
                         (code "i")))
            (entry (% (heading (code "R[i]")))
                   (para "
Red value at table index " (code "i")))
            (entry (% (heading (code "G[i]")))
                   (para "
Green value at table index " (code "i")))
            (entry (% (heading (code "B[i]")))
                   (para "
Blue value at table index " (code "i")))
            (entry (% (heading (code "A[i]")))
                   (para "
Alpha value at table index " (code "i"))))
     (para "
then the result of color table lookup is as follows: ")
     (para)
     (table (% (formatter (asis)))
            (entry (% (heading (strong)))
                   (para (strong "Resulting Texture Components")))
            (entry (% (heading (strong "Table Internal Format")))
                   (para (strong "R")
                         ", "
                         (strong "G")
                         ", "
                         (strong "B")
                         ", "
                         (strong "A")))
            (entry (% (heading (code "GL_ALPHA")))
                   (para (code "R")
                         ", "
                         (code "G")
                         ", "
                         (code "B")
                         ", "
                         (code "A[a]")))
            (entry (% (heading (code "GL_LUMINANCE")))
                   (para (code "L[r]")
                         ", "
                         (code "L[g]")
                         ", "
                         (code "L[b]")
                         ", "
                         (code "At")))
            (entry (% (heading (code "GL_LUMINANCE_ALPHA")))
                   (para (code "L[r]")
                         ", "
                         (code "L[g]")
                         ", "
                         (code "L[b]")
                         ", "
                         (code "A[a]")))
            (entry (% (heading (code "GL_INTENSITY")))
                   (para (code "I[r]")
                         ", "
                         (code "I[g]")
                         ", "
                         (code "I[b]")
                         ", "
                         (code "I[a]")))
            (entry (% (heading (code "GL_RGB")))
                   (para (code "R[r]")
                         ", "
                         (code "G[g]")
                         ", "
                         (code "B[b]")
                         ", "
                         (code "A")))
            (entry (% (heading (code "GL_RGBA")))
                   (para (code "R[r]")
                         ", "
                         (code "G[g]")
                         ", "
                         (code "B[b]")
                         ", "
                         (code "A[a]"))))
     (para "
When "
           (code "GL_COLOR_TABLE")
           " is enabled, the colors resulting from
            the pixel map operation (if it is enabled) are mapped
            by the color lookup table before being passed to the convolution
            operation. The colors resulting from the convolution operation
            are modified by the post convolution color lookup table when "
           (code "GL_POST_CONVOLUTION_COLOR_TABLE")
           "
is enabled. These modified colors are then sent to the color matrix operation.
            Finally, if "
           (code "GL_POST_COLOR_MATRIX_COLOR_TABLE")
           "
is enabled, the colors resulting from the color matrix operation
            are mapped by the post color matrix color lookup table before being
            used by the histogram operation. ")
     (para)
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "target")
           " is not one of the allowable
            values. ")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "internalformat")
           " is not one of the
            allowable values. ")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "format")
           " is not one of the allowable
            values. ")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "type")
           " is not one of the allowable
            values. ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "width")
           " is less than zero. ")
     (para (code "GL_TABLE_TOO_LARGE")
           " is generated if the requested color table
            is too large to be supported by the implementation, and "
           (var "target")
           " is
            not a "
           (code "GL_PROXY_*")
           " target. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target and the buffer object's data store is currently mapped. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target and the data would be unpacked from the buffer 
            object such that the memory reads required would exceed the data store size. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target and "
           (var "data")
           " is not evenly divisible 
            into the number of bytes needed to store in memory a datum indicated by "
           (var "type")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glColorTable")
           " is executed
            between the execution of "
           (code "glBegin")
           " and the corresponding
            execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glColor
  "glColor"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glColor3b"))
      (paramdef "GLbyte " (parameter "red"))
      (paramdef "GLbyte " (parameter "green"))
      (paramdef "GLbyte " (parameter "blue"))))
  '(*fragment*
     (heading "set the current color")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "red")))
                   (itemx (var "green"))
                   (itemx (var "blue"))
                   (para "
Specify new red, green, and blue values for the current color. "))
            (entry (% (heading (var "alpha")))
                   (para "
Specifies a new alpha value for the current color.
                    Included only in the four-argument "
                         (code "glColor4")
                         " commands. ")))
     (heading "Description")
     (para "
The GL stores both a current single-valued color index
            and a current four-valued RGBA color. "
           (code "glColor")
           " sets a new four-valued RGBA color. "
           (code "glColor")
           " has two major variants: "
           (code "glColor3")
           " and "
           (code "glColor4")
           ". "
           (code "glColor3")
           " variants specify new red,
            green,
            and blue values explicitly
            and set the current alpha value to 1.0 (full intensity) implicitly. "
           (code "glColor4")
           " variants specify all four color components explicitly. ")
     (para (code "glColor3b")
           ", "
           (code "glColor4b")
           ", "
           (code "glColor3s")
           ", "
           (code "glColor4s")
           ", "
           (code "glColor3i")
           ", and "
           (code "glColor4i")
           " take
            three or four signed byte, short, or long integers as arguments.
            When "
           (strong "v")
           " is appended to the name,
            the color commands can take a pointer to an array of such values. ")
     (para "
Current color values are stored in floating-point format,
            with unspecified mantissa and exponent sizes.
            Unsigned integer color components,
            when specified,
            are linearly mapped to floating-point values such that the largest
            representable value maps to 1.0 (full intensity),
            and 0 maps to 0.0 (zero intensity).
            Signed integer color components,
            when specified,
            are linearly mapped to floating-point values such that the most positive
            representable value maps to 1.0,
            and the most negative representable value maps to "
           (math "-1.0")
           ".
            (Note that
            this mapping does not convert 0 precisely to 0.0.)
            Floating-point values are mapped directly. ")
     (para "
Neither floating-point nor signed integer values are clamped
            to the range "
           (math "[" "0" "," "1" "]")
           "
before the current color is updated.
            However,
            color components are clamped to this range before they are interpolated
            or written into a color buffer. ")))

(define-gl-procedure
  glCompileShader
  "glCompileShader"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glCompileShader"))
      (paramdef "GLuint " (parameter "shader"))))
  '(*fragment*
     (heading "Compiles a shader object")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "shader")))
                   (para "Specifies the shader object to be
\t\t    compiled.")))
     (heading "Description")
     (para (code "glCompileShader")
           " compiles the source
\tcode strings that have been stored in the shader object
\tspecified by "
           (var "shader")
           ".")
     (para "The compilation status will be stored as part of the
\tshader object's state. This value will be set to\t"
           (code "GL_TRUE")
           " if the shader was compiled without
\terrors and is ready for use, and "
           (code "GL_FALSE")
           "
otherwise. It can be queried by calling\t"
           (code "glGetShader")
           "
with arguments "
           (var "shader")
           " and\t"
           (code "GL_COMPILE_STATUS")
           ".")
     (para "Compilation of a shader can fail for a number of reasons
\tas specified by the OpenGL Shading Language Specification.
\tWhether or not the compilation was successful, information about
\tthe compilation can be obtained from the shader object's
\tinformation log by calling\t"
           (code "glGetShaderInfoLog")
           ".")
     (heading "Errors")
     (para (code "GL_INVALID_VALUE")
           " is generated if\t"
           (var "shader")
           " is not a value generated by
\tOpenGL.")
     (para (code "GL_INVALID_OPERATION")
           " is generated if\t"
           (var "shader")
           " is not a shader object.")
     (para (code "GL_INVALID_OPERATION")
           " is generated if\t"
           (code "glCompileShader")
           " is executed between the
\texecution of\t"
           (code "glBegin")
           "
and the corresponding execution of\t"
           (code "glEnd")
           ".")))

(define-gl-procedure
  glCompressedTexImage1D
  "glCompressedTexImage1D"
  (funcsynopsis
    (funcprototype
      (funcdef
        "void "
        (function "glCompressedTexImage1D"))
      (paramdef "GLenum " (parameter "target"))
      (paramdef "GLint " (parameter "level"))
      (paramdef "GLenum " (parameter "internalformat"))
      (paramdef "GLsizei " (parameter "width"))
      (paramdef "GLint " (parameter "border"))
      (paramdef "GLsizei " (parameter "imageSize"))
      (paramdef "const GLvoid * " (parameter "data"))))
  '(*fragment*
     (heading
       "specify a one-dimensional texture image in a compressed format")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "target")))
                   (para "
Specifies the target texture.
                    Must be "
                         (code "GL_TEXTURE_1D")
                         " or "
                         (code "GL_PROXY_TEXTURE_1D")
                         ". "))
            (entry (% (heading (var "level")))
                   (para "
Specifies the level-of-detail number.
                    Level 0 is the base image level.
                    Level "
                         (var "n")
                         " is the "
                         (var "n")
                         "th mipmap reduction image. "))
            (entry (% (heading (var "internalformat")))
                   (para "
Specifies the format of the compressed image data stored at address "
                         (var "data")
                         ". "))
            (entry (% (heading (var "width")))
                   (para "
Specifies the width of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be "
                         (math "2"
                               "^"
                               (var "n")
                               "+"
                               "2"
                               "\u2061"
                               "("
                               (var "border")
                               ","
                               ")")
                         "
for some integer "
                         (math (var "n"))
                         ".
                    All implementations support texture images that are at least 64 texels wide. The height of the 1D texture image is 1. "))
            (entry (% (heading (var "border")))
                   (para "
Specifies the width of the border. Must be either 0 or 1. "))
            (entry (% (heading (var "imageSize")))
                   (para "
Specifies the number of unsigned bytes of image data starting at the address specified by "
                         (var "data")
                         ". "))
            (entry (% (heading (var "data")))
                   (para "
Specifies a pointer to the compressed image data in memory. ")))
     (heading "Description")
     (para "
Texturing maps a portion of a specified texture image onto each graphical primitive for which texturing is enabled.  To enable and disable one-dimensional texturing, call "
           (code "glEnable")
           " and "
           (code "glDisable")
           " with argument "
           (code "GL_TEXTURE_1D")
           ". ")
     (para (code "glCompressedTexImage1D")
           " loads a previously defined, and retrieved, compressed one-dimensional texture image if "
           (var "target")
           " is "
           (code "GL_TEXTURE_1D")
           " (see "
           (code "glTexImage1D")
           "). ")
     (para "
If "
           (var "target")
           " is "
           (code "GL_PROXY_TEXTURE_1D")
           ", no data is read from "
           (var "data")
           ", but
            all of the texture image state is recalculated, checked for consistency, and checked against the implementation's capabilities.  If the implementation cannot handle a texture of the requested texture size, it sets all of the image state to 0, but does not generate an error (see "
           (code "glGetError")
           "). To query for an entire mipmap array, use an image array level greater than or equal to 1. ")
     (para (var "internalformat")
           " must be extension-specified compressed-texture format. When a texture is loaded with "
           (code "glTexImage1D")
           " using a generic compressed  texture format (e.g., "
           (code "GL_COMPRESSED_RGB")
           ") the GL selects from one of
            its extensions supporting compressed textures.  In order to load the
            compressed texture image using "
           (code "glCompressedTexImage1D")
           ", query the compressed texture image's size and format using "
           (code "glGetTexLevelParameter")
           ". ")
     (para "
If a non-zero named buffer object is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target 
            (see "
           (code "glBindBuffer")
           ") while a texture image is
            specified, "
           (var "data")
           " is treated as a byte offset into the buffer object's data store. ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "internalformat")
           " is one of the generic compressed internal formats: "
           (code "GL_COMPRESSED_ALPHA")
           ", "
           (code "GL_COMPRESSED_LUMINANCE")
           ", "
           (code "GL_COMPRESSED_LUMINANCE_ALPHA")
           ", "
           (code "GL_COMPRESSED_INTENSITY")
           ", "
           (code "GL_COMPRESSED_RGB")
           ", or "
           (code "GL_COMPRESSED_RGBA")
           ". ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "imageSize")
           " is not consistent with
            the format, dimensions, and contents of the specified compressed image
            data. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if parameter combinations are not
            supported by the specific compressed internal format as specified in the
            specific texture compression extension. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target and the buffer object's data store is currently mapped. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target and the data would be unpacked from the buffer 
            object such that the memory reads required would exceed the data store size. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glCompressedTexImage1D")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")
     (para "
Undefined results, including abnormal program termination, are generated if "
           (var "data")
           " is not encoded in a manner consistent with the extension
            specification defining the internal compression format. ")))

(define-gl-procedure
  glCompressedTexImage2D
  "glCompressedTexImage2D"
  (funcsynopsis
    (funcprototype
      (funcdef
        "void "
        (function "glCompressedTexImage2D"))
      (paramdef "GLenum " (parameter "target"))
      (paramdef "GLint " (parameter "level"))
      (paramdef "GLenum " (parameter "internalformat"))
      (paramdef "GLsizei " (parameter "width"))
      (paramdef "GLsizei " (parameter "height"))
      (paramdef "GLint " (parameter "border"))
      (paramdef "GLsizei " (parameter "imageSize"))
      (paramdef "const GLvoid * " (parameter "data"))))
  '(*fragment*
     (heading
       "specify a two-dimensional texture image in a compressed format")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "target")))
                   (para "
Specifies the target texture.
                    Must be "
                         (code "GL_TEXTURE_2D")
                         ", "
                         (code "GL_PROXY_TEXTURE_2D")
                         ", "
                         (code "GL_TEXTURE_CUBE_MAP_POSITIVE_X")
                         ", "
                         (code "GL_TEXTURE_CUBE_MAP_NEGATIVE_X")
                         ", "
                         (code "GL_TEXTURE_CUBE_MAP_POSITIVE_Y")
                         ", "
                         (code "GL_TEXTURE_CUBE_MAP_NEGATIVE_Y")
                         ", "
                         (code "GL_TEXTURE_CUBE_MAP_POSITIVE_Z")
                         ", "
                         (code "GL_TEXTURE_CUBE_MAP_NEGATIVE_Z")
                         ", or "
                         (code "GL_PROXY_TEXTURE_CUBE_MAP")
                         ". "))
            (entry (% (heading (var "level")))
                   (para "
Specifies the level-of-detail number.
                    Level 0 is the base image level.
                    Level "
                         (var "n")
                         " is the "
                         (var "n")
                         "th mipmap reduction image. "))
            (entry (% (heading (var "internalformat")))
                   (para "
Specifies the format of the compressed image data stored at address "
                         (var "data")
                         ". "))
            (entry (% (heading (var "width")))
                   (para "
Specifies the width of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be "
                         (math "2"
                               "^"
                               (var "n")
                               "+"
                               "2"
                               "\u2061"
                               "("
                               (var "border")
                               ","
                               ")")
                         "
for some integer "
                         (math (var "n"))
                         ".
                    All
                    implementations support 2D texture images that are at least 64 texels
                    wide and cube-mapped texture images that are at least 16 texels wide. "))
            (entry (% (heading (var "height")))
                   (para "
Specifies the height of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be 
                    Must be "
                         (math "2"
                               "^"
                               (var "n")
                               "+"
                               "2"
                               "\u2061"
                               "("
                               (var "border")
                               ","
                               ")")
                         "
for some integer "
                         (math (var "n"))
                         ".
                    All
                    implementations support 2D texture images that are at least 64 texels
                    high and cube-mapped texture images that are at least 16 texels high. "))
            (entry (% (heading (var "border")))
                   (para "
Specifies the width of the border.
                    Must be either 0 or 1. "))
            (entry (% (heading (var "imageSize")))
                   (para "
Specifies the number of unsigned bytes of image data starting at the
                    address specified by "
                         (var "data")
                         ". "))
            (entry (% (heading (var "data")))
                   (para "
Specifies a pointer to the compressed image data in memory. ")))
     (heading "Description")
     (para "
Texturing maps a portion of a specified texture image onto each graphical
            primitive for which texturing is enabled.  To enable and disable
            two-dimensional texturing, call "
           (code "glEnable")
           " and "
           (code "glDisable")
           " with argument "
           (code "GL_TEXTURE_2D")
           ".  To enable and disable texturing using
            cube-mapped textures, call "
           (code "glEnable")
           " and "
           (code "glDisable")
           " with argument "
           (code "GL_TEXTURE_CUBE_MAP")
           ". ")
     (para (code "glCompressedTexImage2D")
           " loads a previously defined, and retrieved, compressed two-dimensional
            texture image if "
           (var "target")
           " is "
           (code "GL_TEXTURE_2D")
           " (see "
           (code "glTexImage2D")
           "). ")
     (para "
If "
           (var "target")
           " is "
           (code "GL_PROXY_TEXTURE_2D")
           ", no data is read from "
           (var "data")
           ", but
            all of the texture image state is recalculated, checked for consistency,
            and checked against the implementation's capabilities.  If the
            implementation cannot handle a texture of the requested texture size, it
            sets all of the image state to 0, but does not generate an error (see "
           (code "glGetError")
           "). To query for an entire mipmap array, use an image array level
            greater than or equal to 1. ")
     (para (var "internalformat")
           " must be an extension-specified compressed-texture format.
            When a texture is loaded with "
           (code "glTexImage2D")
           " using a generic compressed
            texture format (e.g., "
           (code "GL_COMPRESSED_RGB")
           "), the GL selects from one of
            its extensions supporting compressed textures.  In order to load the
            compressed texture image using "
           (code "glCompressedTexImage2D")
           ", query the compressed texture image's
            size and format using "
           (code "glGetTexLevelParameter")
           ". ")
     (para "
If a non-zero named buffer object is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target 
            (see "
           (code "glBindBuffer")
           ") while a texture image is
            specified, "
           (var "data")
           " is treated as a byte offset into the buffer object's data store. ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "internalformat")
           " is one of the generic compressed internal formats: "
           (code "GL_COMPRESSED_ALPHA")
           ", "
           (code "GL_COMPRESSED_LUMINANCE")
           ", "
           (code "GL_COMPRESSED_LUMINANCE_ALPHA")
           ", "
           (code "GL_COMPRESSED_INTENSITY")
           ", "
           (code "GL_COMPRESSED_RGB")
           ", or "
           (code "GL_COMPRESSED_RGBA")
           ". ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "imageSize")
           " is not consistent with
            the format, dimensions, and contents of the specified compressed image
            data. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if parameter combinations are not
            supported by the specific compressed internal format as specified in the
            specific texture compression extension. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target and the buffer object's data store is currently mapped. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target and the data would be unpacked from the buffer 
            object such that the memory reads required would exceed the data store size. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glCompressedTexImage2D")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")
     (para "
Undefined results, including abnormal program termination, are generated if "
           (var "data")
           " is not encoded in a manner consistent with the extension
            specification defining the internal compression format. ")))

(define-gl-procedure
  glCompressedTexImage3D
  "glCompressedTexImage3D"
  (funcsynopsis
    (funcprototype
      (funcdef
        "void "
        (function "glCompressedTexImage3D"))
      (paramdef "GLenum " (parameter "target"))
      (paramdef "GLint " (parameter "level"))
      (paramdef "GLenum " (parameter "internalformat"))
      (paramdef "GLsizei " (parameter "width"))
      (paramdef "GLsizei " (parameter "height"))
      (paramdef "GLsizei " (parameter "depth"))
      (paramdef "GLint " (parameter "border"))
      (paramdef "GLsizei " (parameter "imageSize"))
      (paramdef "const GLvoid * " (parameter "data"))))
  '(*fragment*
     (heading
       "specify a three-dimensional texture image in a compressed format")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "target")))
                   (para "
Specifies the target texture.
                    Must be "
                         (code "GL_TEXTURE_3D")
                         " or "
                         (code "GL_PROXY_TEXTURE_3D")
                         ". "))
            (entry (% (heading (var "level")))
                   (para "
Specifies the level-of-detail number.
                    Level 0 is the base image level.
                    Level "
                         (var "n")
                         " is the "
                         (var "n")
                         "th mipmap reduction image. "))
            (entry (% (heading (var "internalformat")))
                   (para "
Specifies the format of the compressed image data stored at address "
                         (var "data")
                         ". "))
            (entry (% (heading (var "width")))
                   (para "
Specifies the width of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be "
                         (math "2"
                               "^"
                               (var "n")
                               "+"
                               "2"
                               "\u2061"
                               "("
                               (var "border")
                               ","
                               ")")
                         "
for some integer "
                         (math (var "n"))
                         ".
                    All
                    implementations support 3D texture images that are at least 16 texels
                    wide. "))
            (entry (% (heading (var "height")))
                   (para "
Specifies the height of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be "
                         (math "2"
                               "^"
                               (var "n")
                               "+"
                               "2"
                               "\u2061"
                               "("
                               (var "border")
                               ","
                               ")")
                         "
for some integer "
                         (math (var "n"))
                         ".
                    All
                    implementations support 3D texture images that are at least 16 texels
                    high. "))
            (entry (% (heading (var "depth")))
                   (para "
Specifies the depth of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be "
                         (math "2"
                               "^"
                               (var "n")
                               "+"
                               "2"
                               "\u2061"
                               "("
                               (var "border")
                               ","
                               ")")
                         "
for some integer "
                         (math (var "n"))
                         ".
                    All
                    implementations support 3D texture images that are at least 16 texels
                    deep. "))
            (entry (% (heading (var "border")))
                   (para "
Specifies the width of the border.
                    Must be either 0 or 1. "))
            (entry (% (heading (var "imageSize")))
                   (para "
Specifies the number of unsigned bytes of image data starting at the
                    address specified by "
                         (var "data")
                         ". "))
            (entry (% (heading (var "data")))
                   (para "
Specifies a pointer to the compressed image data in memory. ")))
     (heading "Description")
     (para "
Texturing maps a portion of a specified texture image onto each graphical
            primitive for which texturing is enabled.  To enable and disable
            three-dimensional texturing, call "
           (code "glEnable")
           " and "
           (code "glDisable")
           " with argument "
           (code "GL_TEXTURE_3D")
           ". ")
     (para (code "glCompressedTexImage3D")
           " loads a previously defined, and retrieved, compressed three-dimensional
            texture image if "
           (var "target")
           " is "
           (code "GL_TEXTURE_3D")
           " (see "
           (code "glTexImage3D")
           "). ")
     (para "
If "
           (var "target")
           " is "
           (code "GL_PROXY_TEXTURE_3D")
           ", no data is read from "
           (var "data")
           ", but
            all of the texture image state is recalculated, checked for consistency,
            and checked against the implementation's capabilities.  If the
            implementation cannot handle a texture of the requested texture size, it
            sets all of the image state to 0, but does not generate an error (see "
           (code "glGetError")
           "). To query for an entire mipmap array, use an image array level
            greater than or equal to 1. ")
     (para (var "internalformat")
           " must be an extension-specified compressed-texture format.
            When a texture is loaded with "
           (code "glTexImage2D")
           " using a generic compressed
            texture format (e.g., "
           (code "GL_COMPRESSED_RGB")
           "), the GL selects from one of
            its extensions supporting compressed textures.  In order to load the
            compressed texture image using "
           (code "glCompressedTexImage3D")
           ", query the compressed texture image's
            size and format using "
           (code "glGetTexLevelParameter")
           ". ")
     (para "
If a non-zero named buffer object is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target 
            (see "
           (code "glBindBuffer")
           ") while a texture image is
            specified, "
           (var "data")
           " is treated as a byte offset into the buffer object's data store. ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "internalformat")
           " is one of the generic compressed internal formats: "
           (code "GL_COMPRESSED_ALPHA")
           ", "
           (code "GL_COMPRESSED_LUMINANCE")
           ", "
           (code "GL_COMPRESSED_LUMINANCE_ALPHA")
           ", "
           (code "GL_COMPRESSED_INTENSITY")
           ", "
           (code "GL_COMPRESSED_RGB")
           ", or "
           (code "GL_COMPRESSED_RGBA")
           ". ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "imageSize")
           " is not consistent with
            the format, dimensions, and contents of the specified compressed image data. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if parameter combinations are not
            supported by the specific compressed internal format as specified in the
            specific texture compression extension. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target and the buffer object's data store is currently mapped. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target and the data would be unpacked from the buffer 
            object such that the memory reads required would exceed the data store size. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glCompressedTexImage3D")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")
     (para "
Undefined results, including abnormal program termination, are generated if "
           (var "data")
           " is not encoded in a manner consistent with the extension specification defining the internal compression format. ")))

(define-gl-procedure
  glCompressedTexSubImage1D
  "glCompressedTexSubImage1D"
  (funcsynopsis
    (funcprototype
      (funcdef
        "void "
        (function "glCompressedTexSubImage1D"))
      (paramdef "GLenum " (parameter "target"))
      (paramdef "GLint " (parameter "level"))
      (paramdef "GLint " (parameter "xoffset"))
      (paramdef "GLsizei " (parameter "width"))
      (paramdef "GLenum " (parameter "format"))
      (paramdef "GLsizei " (parameter "imageSize"))
      (paramdef "const GLvoid * " (parameter "data"))))
  '(*fragment*
     (heading
       "specify a one-dimensional texture subimage in a compressed format")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "target")))
                   (para "
Specifies the target texture.
                    Must be "
                         (code "GL_TEXTURE_1D")
                         ". "))
            (entry (% (heading (var "level")))
                   (para "
Specifies the level-of-detail number.
                    Level 0 is the base image level.
                    Level "
                         (var "n")
                         " is the "
                         (var "n")
                         "th mipmap reduction image. "))
            (entry (% (heading (var "xoffset")))
                   (para "
Specifies a texel offset in the x direction within the texture array. "))
            (entry (% (heading (var "width")))
                   (para "
Specifies the width of the texture subimage. "))
            (entry (% (heading (var "format")))
                   (para "
Specifies the format of the compressed image data stored at address "
                         (var "data")
                         ". "))
            (entry (% (heading (var "imageSize")))
                   (para "
Specifies the number of unsigned bytes of image data starting at the
                    address specified by "
                         (var "data")
                         ". "))
            (entry (% (heading (var "data")))
                   (para "
Specifies a pointer to the compressed image data in memory. ")))
     (heading "Description")
     (para "
Texturing maps a portion of a specified texture image onto each graphical
            primitive for which texturing is enabled.  To enable and disable
            one-dimensional texturing, call "
           (code "glEnable")
           " and "
           (code "glDisable")
           " with argument "
           (code "GL_TEXTURE_1D")
           ". ")
     (para (code "glCompressedTexSubImage1D")
           " redefines a contiguous subregion of an existing one-dimensional
            texture image.  The texels referenced by "
           (var "data")
           " replace the portion of the
            existing texture array with x indices "
           (var "xoffset")
           " and "
           (math (var "xoffset") "+" (var "width") "-" "1")
           ",
            inclusive.  This region may not include any texels
            outside the range of the texture array as it was originally specified.  It
            is not an error to specify a subtexture with width of 0, but such a
            specification has no effect. ")
     (para (var "format")
           " must be an extension-specified
            compressed-texture format.  The "
           (var "format")
           " of the compressed texture
            image is selected by the GL implementation that compressed it (see "
           (code "glTexImage1D")
           "), and should be queried at the time the texture was
            compressed with "
           (code "glGetTexLevelParameter")
           ". ")
     (para "
If a non-zero named buffer object is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target 
            (see "
           (code "glBindBuffer")
           ") while a texture image is
            specified, "
           (var "data")
           " is treated as a byte offset into the buffer object's data store. ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "format")
           " is one of these generic compressed internal formats: "
           (code "GL_COMPRESSED_ALPHA")
           ", "
           (code "GL_COMPRESSED_LUMINANCE")
           ", "
           (code "GL_COMPRESSED_LUMINANCE_ALPHA")
           ", "
           (code "GL_COMPRESSED_INTENSITY")
           ", "
           (code "GL_COMPRESSED_RGB")
           ", "
           (code "GL_COMPRESSED_RGBA")
           ",\t"
           (code "GL_COMPRESSED_SLUMINANCE")
           ",\t"
           (code "GL_COMPRESSED_SLUMINANCE_ALPHA")
           ",\t"
           (code "GL_COMPRESSED_SRGB")
           ",\t"
           (code "GL_COMPRESSED_SRGBA")
           ", or\t"
           (code "GL_COMPRESSED_SRGB_ALPHA")
           ". ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "imageSize")
           " is not consistent with
            the format, dimensions, and contents of the specified compressed image
            data. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if parameter combinations are not
            supported by the specific compressed internal format as specified in the
            specific texture compression extension. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target and the buffer object's data store is currently mapped. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target and the data would be unpacked from the buffer 
            object such that the memory reads required would exceed the data store size. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glCompressedTexSubImage1D")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")
     (para "
Undefined results, including abnormal program termination, are generated if "
           (var "data")
           " is not encoded in a manner consistent with the extension
            specification defining the internal compression format. ")))

(define-gl-procedure
  glCompressedTexSubImage2D
  "glCompressedTexSubImage2D"
  (funcsynopsis
    (funcprototype
      (funcdef
        "void "
        (function "glCompressedTexSubImage2D"))
      (paramdef "GLenum " (parameter "target"))
      (paramdef "GLint " (parameter "level"))
      (paramdef "GLint " (parameter "xoffset"))
      (paramdef "GLint " (parameter "yoffset"))
      (paramdef "GLsizei " (parameter "width"))
      (paramdef "GLsizei " (parameter "height"))
      (paramdef "GLenum " (parameter "format"))
      (paramdef "GLsizei " (parameter "imageSize"))
      (paramdef "const GLvoid * " (parameter "data"))))
  '(*fragment*
     (heading
       "specify a two-dimensional texture subimage in a compressed format")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "target")))
                   (para "
Specifies the target texture.
                    Must be "
                         (code "GL_TEXTURE_2D")
                         ", "
                         (code "GL_TEXTURE_CUBE_MAP_POSITIVE_X")
                         ", "
                         (code "GL_TEXTURE_CUBE_MAP_NEGATIVE_X")
                         ", "
                         (code "GL_TEXTURE_CUBE_MAP_POSITIVE_Y")
                         ", "
                         (code "GL_TEXTURE_CUBE_MAP_NEGATIVE_Y")
                         ", "
                         (code "GL_TEXTURE_CUBE_MAP_POSITIVE_Z")
                         ", or "
                         (code "GL_TEXTURE_CUBE_MAP_NEGATIVE_Z")
                         ". "))
            (entry (% (heading (var "level")))
                   (para "
Specifies the level-of-detail number.
                    Level 0 is the base image level.
                    Level "
                         (var "n")
                         " is the "
                         (var "n")
                         "th mipmap reduction image. "))
            (entry (% (heading (var "xoffset")))
                   (para "
Specifies a texel offset in the x direction within the texture array. "))
            (entry (% (heading (var "yoffset")))
                   (para "
Specifies a texel offset in the y direction within the texture array. "))
            (entry (% (heading (var "width")))
                   (para "
Specifies the width of the texture subimage. "))
            (entry (% (heading (var "height")))
                   (para "
Specifies the height of the texture subimage. "))
            (entry (% (heading (var "format")))
                   (para "
Specifies the format of the compressed image data stored at address "
                         (var "data")
                         ". "))
            (entry (% (heading (var "imageSize")))
                   (para "
Specifies the number of unsigned bytes of image data starting at the
                    address specified by "
                         (var "data")
                         ". "))
            (entry (% (heading (var "data")))
                   (para "
Specifies a pointer to the compressed image data in memory. ")))
     (heading "Description")
     (para "
Texturing maps a portion of a specified texture image onto each graphical
            primitive for which texturing is enabled.  To enable and disable
            two-dimensional texturing, call "
           (code "glEnable")
           " and "
           (code "glDisable")
           " with argument "
           (code "GL_TEXTURE_2D")
           ".   To enable and disable texturing using
            cube-mapped texture, call "
           (code "glEnable")
           " and "
           (code "glDisable")
           " with argument "
           (code "GL_TEXTURE_CUBE_MAP")
           ". ")
     (para (code "glCompressedTexSubImage2D")
           " redefines a contiguous subregion of an existing two-dimensional
            texture image.  The texels referenced by "
           (var "data")
           " replace the portion of the
            existing texture array with x indices "
           (var "xoffset")
           " and "
           (math (var "xoffset") "+" (var "width") "-" "1")
           ",
            and the y indices "
           (var "yoffset")
           " and "
           (math (var "yoffset") "+" (var "height") "-" "1")
           ",
            inclusive.  
            This region may not include any texels
            outside the range of the texture array as it was originally specified.  It
            is not an error to specify a subtexture with width of 0, but such a
            specification has no effect. ")
     (para (var "format")
           " must be an extension-specified
            compressed-texture format.  The "
           (var "format")
           " of the compressed texture
            image is selected by the GL implementation that compressed it (see "
           (code "glTexImage2D")
           ") and should be queried at the time the texture was
            compressed with "
           (code "glGetTexLevelParameter")
           ". ")
     (para "
If a non-zero named buffer object is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target 
            (see "
           (code "glBindBuffer")
           ") while a texture image is
            specified, "
           (var "data")
           " is treated as a byte offset into the buffer object's data store. ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "format")
           " is one of these generic compressed internal formats: "
           (code "GL_COMPRESSED_ALPHA")
           ", "
           (code "GL_COMPRESSED_LUMINANCE")
           ", "
           (code "GL_COMPRESSED_LUMINANCE_ALPHA")
           ", "
           (code "GL_COMPRESSED_INTENSITY")
           ", "
           (code "GL_COMPRESSED_RGB")
           ", "
           (code "GL_COMPRESSED_RGBA")
           ",\t"
           (code "GL_COMPRESSED_SLUMINANCE")
           ",\t"
           (code "GL_COMPRESSED_SLUMINANCE_ALPHA")
           ",\t"
           (code "GL_COMPRESSED_SRGB")
           ",\t"
           (code "GL_COMPRESSED_SRGBA")
           ", or\t"
           (code "GL_COMPRESSED_SRGB_ALPHA")
           ". ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "imageSize")
           " is not consistent with
            the format, dimensions, and contents of the specified compressed image
            data. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if parameter combinations are not
            supported by the specific compressed internal format as specified in the
            specific texture compression extension. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target and the buffer object's data store is currently mapped. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target and the data would be unpacked from the buffer 
            object such that the memory reads required would exceed the data store size. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glCompressedTexSubImage2D")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")
     (para "
Undefined results, including abnormal program termination, are generated if "
           (var "data")
           " is not encoded in a manner consistent with the extension
            specification defining the internal compression format. ")))

(define-gl-procedure
  glCompressedTexSubImage3D
  "glCompressedTexSubImage3D"
  (funcsynopsis
    (funcprototype
      (funcdef
        "void "
        (function "glCompressedTexSubImage3D"))
      (paramdef "GLenum " (parameter "target"))
      (paramdef "GLint " (parameter "level"))
      (paramdef "GLint " (parameter "xoffset"))
      (paramdef "GLint " (parameter "yoffset"))
      (paramdef "GLint " (parameter "zoffset"))
      (paramdef "GLsizei " (parameter "width"))
      (paramdef "GLsizei " (parameter "height"))
      (paramdef "GLsizei " (parameter "depth"))
      (paramdef "GLenum " (parameter "format"))
      (paramdef "GLsizei " (parameter "imageSize"))
      (paramdef "const GLvoid * " (parameter "data"))))
  '(*fragment*
     (heading
       "specify a three-dimensional texture subimage in a compressed format")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "target")))
                   (para "
Specifies the target texture.
                    Must be "
                         (code "GL_TEXTURE_3D")
                         ". "))
            (entry (% (heading (var "level")))
                   (para "
Specifies the level-of-detail number.
                    Level 0 is the base image level.
                    Level "
                         (var "n")
                         " is the "
                         (var "n")
                         "th mipmap reduction image. "))
            (entry (% (heading (var "xoffset")))
                   (para "
Specifies a texel offset in the x direction within the texture array. "))
            (entry (% (heading (var "yoffset")))
                   (para "
Specifies a texel offset in the y direction within the texture array. "))
            (entry (% (heading (var "width")))
                   (para "
Specifies the width of the texture subimage. "))
            (entry (% (heading (var "height")))
                   (para "
Specifies the height of the texture subimage. "))
            (entry (% (heading (var "depth")))
                   (para "
Specifies the depth of the texture subimage. "))
            (entry (% (heading (var "format")))
                   (para "
Specifies the format of the compressed image data stored at address "
                         (var "data")
                         ". "))
            (entry (% (heading (var "imageSize")))
                   (para "
Specifies the number of unsigned bytes of image data starting at the
                    address specified by "
                         (var "data")
                         ". "))
            (entry (% (heading (var "data")))
                   (para "
Specifies a pointer to the compressed image data in memory. ")))
     (heading "Description")
     (para "
Texturing maps a portion of a specified texture image onto each graphical
            primitive for which texturing is enabled.  To enable and disable
            three-dimensional texturing, call "
           (code "glEnable")
           " and "
           (code "glDisable")
           " with argument "
           (code "GL_TEXTURE_3D")
           ". ")
     (para (code "glCompressedTexSubImage3D")
           " redefines a contiguous subregion of an existing three-dimensional
            texture image.  The texels referenced by "
           (var "data")
           " replace the portion of the
            existing texture array with x indices "
           (var "xoffset")
           " and "
           (math (var "xoffset") "+" (var "width") "-" "1")
           ",
            and the y indices "
           (var "yoffset")
           " and "
           (math (var "yoffset") "+" (var "height") "-" "1")
           ",
            and the z indices "
           (var "zoffset")
           " and "
           (math (var "zoffset") "+" (var "depth") "-" "1")
           ",
            inclusive.  This region may not include
            any texels outside the range of the texture array as it was originally
            specified.  It is not an error to specify a subtexture with width of 0,
            but such a specification has no effect. ")
     (para (var "format")
           " must be an extension-specified
            compressed-texture format.  The "
           (var "format")
           " of the compressed texture
            image is selected by the GL implementation that compressed it (see "
           (code "glTexImage3D")
           ") and should be queried at the time the texture was
            compressed with "
           (code "glGetTexLevelParameter")
           ". ")
     (para "
If a non-zero named buffer object is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target 
            (see "
           (code "glBindBuffer")
           ") while a texture image is
            specified, "
           (var "data")
           " is treated as a byte offset into the buffer object's data store. ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "format")
           " is one of these generic compressed internal formats: "
           (code "GL_COMPRESSED_ALPHA")
           ", "
           (code "GL_COMPRESSED_LUMINANCE")
           ", "
           (code "GL_COMPRESSED_LUMINANCE_ALPHA")
           ", "
           (code "GL_COMPRESSED_INTENSITY")
           ", "
           (code "GL_COMPRESSED_RGB")
           ", "
           (code "GL_COMPRESSED_RGBA")
           ",\t"
           (code "GL_COMPRESSED_SLUMINANCE")
           ",\t"
           (code "GL_COMPRESSED_SLUMINANCE_ALPHA")
           ",\t"
           (code "GL_COMPRESSED_SRGB")
           ",\t"
           (code "GL_COMPRESSED_SRGBA")
           ", or\t"
           (code "GL_COMPRESSED_SRGB_ALPHA")
           ". ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "imageSize")
           " is not consistent with
            the format, dimensions, and contents of the specified compressed image
            data. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if parameter combinations are not
            supported by the specific compressed internal format as specified in the
            specific texture compression extension. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target and the buffer object's data store is currently mapped. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target and the data would be unpacked from the buffer 
            object such that the memory reads required would exceed the data store size. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glCompressedTexSubImage3D")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")
     (para "
Undefined results, including abnormal program termination, are generated if "
           (var "data")
           " is not encoded in a manner consistent with the extension
            specification defining the internal compression format. ")))

(define-gl-procedure
  glConvolutionFilter1D
  "glConvolutionFilter1D"
  (funcsynopsis
    (funcprototype
      (funcdef
        "void "
        (function "glConvolutionFilter1D"))
      (paramdef "GLenum " (parameter "target"))
      (paramdef "GLenum " (parameter "internalformat"))
      (paramdef "GLsizei " (parameter "width"))
      (paramdef "GLenum " (parameter "format"))
      (paramdef "GLenum " (parameter "type"))
      (paramdef "const GLvoid * " (parameter "data"))))
  '(*fragment*
     (heading
       "define a one-dimensional convolution filter")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "target")))
                   (para "
Must be "
                         (code "GL_CONVOLUTION_1D")
                         ". "))
            (entry (% (heading (var "internalformat")))
                   (para "
The internal format of the convolution filter kernel.
                    The allowable values are "
                         (code "GL_ALPHA")
                         ", "
                         (code "GL_ALPHA4")
                         ", "
                         (code "GL_ALPHA8")
                         ", "
                         (code "GL_ALPHA12")
                         ", "
                         (code "GL_ALPHA16")
                         ", "
                         (code "GL_LUMINANCE")
                         ", "
                         (code "GL_LUMINANCE4")
                         ", "
                         (code "GL_LUMINANCE8")
                         ", "
                         (code "GL_LUMINANCE12")
                         ", "
                         (code "GL_LUMINANCE16")
                         ", "
                         (code "GL_LUMINANCE_ALPHA")
                         ", "
                         (code "GL_LUMINANCE4_ALPHA4")
                         ", "
                         (code "GL_LUMINANCE6_ALPHA2")
                         ", "
                         (code "GL_LUMINANCE8_ALPHA8")
                         ", "
                         (code "GL_LUMINANCE12_ALPHA4")
                         ", "
                         (code "GL_LUMINANCE12_ALPHA12")
                         ", "
                         (code "GL_LUMINANCE16_ALPHA16")
                         ", "
                         (code "GL_INTENSITY")
                         ", "
                         (code "GL_INTENSITY4")
                         ", "
                         (code "GL_INTENSITY8")
                         ", "
                         (code "GL_INTENSITY12")
                         ", "
                         (code "GL_INTENSITY16")
                         ", "
                         (code "GL_R3_G3_B2")
                         ", "
                         (code "GL_RGB")
                         ", "
                         (code "GL_RGB4")
                         ", "
                         (code "GL_RGB5")
                         ", "
                         (code "GL_RGB8")
                         ", "
                         (code "GL_RGB10")
                         ", "
                         (code "GL_RGB12")
                         ", "
                         (code "GL_RGB16")
                         ", "
                         (code "GL_RGBA")
                         ", "
                         (code "GL_RGBA2")
                         ", "
                         (code "GL_RGBA4")
                         ", "
                         (code "GL_RGB5_A1")
                         ", "
                         (code "GL_RGBA8")
                         ", "
                         (code "GL_RGB10_A2")
                         ", "
                         (code "GL_RGBA12")
                         ", or "
                         (code "GL_RGBA16")
                         ". "))
            (entry (% (heading (var "width")))
                   (para "
The width of the pixel array referenced by "
                         (var "data")
                         ". "))
            (entry (% (heading (var "format")))
                   (para "
The format of the pixel data in "
                         (var "data")
                         ".
                    The allowable values are "
                         (code "GL_ALPHA")
                         ", "
                         (code "GL_LUMINANCE")
                         ", "
                         (code "GL_LUMINANCE_ALPHA")
                         ", "
                         (code "GL_INTENSITY")
                         ", "
                         (code "GL_RGB")
                         ", and "
                         (code "GL_RGBA")
                         ". "))
            (entry (% (heading (var "type")))
                   (para "
The type of the pixel data in "
                         (var "data")
                         ".
                    Symbolic constants "
                         (code "GL_UNSIGNED_BYTE")
                         ", "
                         (code "GL_BYTE")
                         ", "
                         (code "GL_BITMAP")
                         ", "
                         (code "GL_UNSIGNED_SHORT")
                         ", "
                         (code "GL_SHORT")
                         ", "
                         (code "GL_UNSIGNED_INT")
                         ", "
                         (code "GL_INT")
                         ", "
                         (code "GL_FLOAT")
                         ", "
                         (code "GL_UNSIGNED_BYTE_3_3_2")
                         ", "
                         (code "GL_UNSIGNED_BYTE_2_3_3_REV")
                         ", "
                         (code "GL_UNSIGNED_SHORT_5_6_5")
                         ", "
                         (code "GL_UNSIGNED_SHORT_5_6_5_REV")
                         ", "
                         (code "GL_UNSIGNED_SHORT_4_4_4_4")
                         ", "
                         (code "GL_UNSIGNED_SHORT_4_4_4_4_REV")
                         ", "
                         (code "GL_UNSIGNED_SHORT_5_5_5_1")
                         ", "
                         (code "GL_UNSIGNED_SHORT_1_5_5_5_REV")
                         ", "
                         (code "GL_UNSIGNED_INT_8_8_8_8")
                         ", "
                         (code "GL_UNSIGNED_INT_8_8_8_8_REV")
                         ", "
                         (code "GL_UNSIGNED_INT_10_10_10_2")
                         ", and "
                         (code "GL_UNSIGNED_INT_2_10_10_10_REV")
                         "
are accepted. "))
            (entry (% (heading (var "data")))
                   (para "
Pointer to a one-dimensional array of pixel data that is processed to
                    build the convolution filter kernel. ")))
     (heading "Description")
     (para (code "glConvolutionFilter1D")
           " builds a one-dimensional convolution filter kernel from an array of
            pixels. ")
     (para "
The pixel array specified by "
           (var "width")
           ", "
           (var "format")
           ", "
           (var "type")
           ", and "
           (var "data")
           "
is extracted from memory and
            processed just as if "
           (code "glDrawPixels")
           " were called, but processing
            stops after the final expansion to RGBA is completed. ")
     (para "
If a non-zero named buffer object is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target 
            (see "
           (code "glBindBuffer")
           ") while a convolution filter is
            specified, "
           (var "data")
           " is treated as a byte offset into the buffer object's data store. ")
     (para "
The R, G, B, and A components of each pixel are next scaled by the four
            1D "
           (code "GL_CONVOLUTION_FILTER_SCALE")
           " parameters and biased by the
            four 1D "
           (code "GL_CONVOLUTION_FILTER_BIAS")
           " parameters.
            (The scale and bias parameters are set by "
           (code "glConvolutionParameter")
           "
using the "
           (code "GL_CONVOLUTION_1D")
           " target and the names "
           (code "GL_CONVOLUTION_FILTER_SCALE")
           " and "
           (code "GL_CONVOLUTION_FILTER_BIAS")
           ".
            The parameters themselves are vectors of four values that are applied to red,
            green, blue, and alpha, in that order.)
            The R, G, B, and A values are not clamped to [0,1] at any time during this
            process. ")
     (para "
Each pixel is then converted to the internal format specified by "
           (var "internalformat")
           ".
            This conversion simply maps the component values of the pixel (R, G, B,
            and A) to the values included in the internal format (red, green, blue,
            alpha, luminance, and intensity).  The mapping is as follows: ")
     (para)
     (table (% (formatter (asis)))
            (entry (% (heading (strong "Internal Format")))
                   (para (strong "Red")
                         ", "
                         (strong "Green")
                         ", "
                         (strong "Blue")
                         ", "
                         (strong "Alpha")
                         ", "
                         (strong "Luminance")
                         ", "
                         (strong "Intensity")))
            (entry (% (heading (code "GL_ALPHA")))
                   (para ", " ", " ", " "
A " ", " ", "))
            (entry (% (heading (code "GL_LUMINANCE")))
                   (para ", " ", " ", " ", " "
R " ", "))
            (entry (% (heading (code "GL_LUMINANCE_ALPHA")))
                   (para ", " ", " ", " "
A " ", " "
R " ", "))
            (entry (% (heading (code "GL_INTENSITY")))
                   (para ", " ", " ", " ", " ", " "
R "))
            (entry (% (heading (code "GL_RGB")))
                   (para "
R " ", " "
G " ", " "
B " ", " ", " ", "))
            (entry (% (heading (code "GL_RGBA")))
                   (para "
R "
                         ", "
                         "
G "
                         ", "
                         "
B "
                         ", "
                         "
A "
                         ", "
                         ", ")))
     (para "
The red, green, blue, alpha, luminance, and/or intensity components of
            the resulting pixels are stored in floating-point rather than integer
            format.
            They form a one-dimensional filter kernel image indexed with coordinate "
           (var "i")
           " such that "
           (var "i")
           " starts at 0 and increases from left to right.
            Kernel location "
           (var "i")
           " is derived from the "
           (var "i")
           "th pixel, counting from 0. ")
     (para "
Note that after a convolution is performed, the resulting color
            components are also scaled by their corresponding "
           (code "GL_POST_CONVOLUTION_c_SCALE")
           " parameters and biased by their
            corresponding "
           (code "GL_POST_CONVOLUTION_c_BIAS")
           " parameters (where "
           (var "c")
           " takes on the values "
           (strong "RED")
           ", "
           (strong "GREEN")
           ", "
           (strong "BLUE")
           ", and "
           (strong "ALPHA")
           ").
            These parameters are set by "
           (code "glPixelTransfer")
           ". ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "target")
           " is not "
           (code "GL_CONVOLUTION_1D")
           ". ")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "internalformat")
           " is not one of the
            allowable values. ")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "format")
           " is not one of the allowable
            values. ")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "type")
           " is not one of the allowable
            values. ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "width")
           " is less than zero or greater
            than the maximum supported value.
            This value may be queried with "
           (code "glGetConvolutionParameter")
           "
using target "
           (code "GL_CONVOLUTION_1D")
           " and name "
           (code "GL_MAX_CONVOLUTION_WIDTH")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (var "format")
           " is one of "
           (code "GL_UNSIGNED_BYTE_3_3_2")
           ", "
           (code "GL_UNSIGNED_BYTE_2_3_3_REV")
           ", "
           (code "GL_UNSIGNED_SHORT_5_6_5")
           ", or "
           (code "GL_UNSIGNED_SHORT_5_6_5_REV")
           "
and "
           (var "type")
           " is not "
           (code "GL_RGB")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (var "format")
           " is one of "
           (code "GL_UNSIGNED_SHORT_4_4_4_4")
           ", "
           (code "GL_UNSIGNED_SHORT_4_4_4_4_REV")
           ", "
           (code "GL_UNSIGNED_SHORT_5_5_5_1")
           ", "
           (code "GL_UNSIGNED_SHORT_1_5_5_5_REV")
           ", "
           (code "GL_UNSIGNED_INT_8_8_8_8")
           ", "
           (code "GL_UNSIGNED_INT_8_8_8_8_REV")
           ", "
           (code "GL_UNSIGNED_INT_10_10_10_2")
           ", or "
           (code "GL_UNSIGNED_INT_2_10_10_10_REV")
           "
and "
           (var "type")
           " is neither "
           (code "GL_RGBA")
           " nor "
           (code "GL_BGRA")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target and the buffer object's data store is currently mapped. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target and the data would be unpacked from the buffer 
            object such that the memory reads required would exceed the data store size. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target and "
           (var "data")
           " is not evenly divisible 
            into the number of bytes needed to store in memory a datum indicated by "
           (var "type")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glConvolutionFilter1D")
           " is executed
            between the execution of "
           (code "glBegin")
           " and the corresponding
            execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glConvolutionFilter2D
  "glConvolutionFilter2D"
  (funcsynopsis
    (funcprototype
      (funcdef
        "void "
        (function "glConvolutionFilter2D"))
      (paramdef "GLenum " (parameter "target"))
      (paramdef "GLenum " (parameter "internalformat"))
      (paramdef "GLsizei " (parameter "width"))
      (paramdef "GLsizei " (parameter "height"))
      (paramdef "GLenum " (parameter "format"))
      (paramdef "GLenum " (parameter "type"))
      (paramdef "const GLvoid * " (parameter "data"))))
  '(*fragment*
     (heading
       "define a two-dimensional convolution filter")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "target")))
                   (para "
Must be "
                         (code "GL_CONVOLUTION_2D")
                         ". "))
            (entry (% (heading (var "internalformat")))
                   (para "
The internal format of the convolution filter kernel.
                    The allowable values are "
                         (code "GL_ALPHA")
                         ", "
                         (code "GL_ALPHA4")
                         ", "
                         (code "GL_ALPHA8")
                         ", "
                         (code "GL_ALPHA12")
                         ", "
                         (code "GL_ALPHA16")
                         ", "
                         (code "GL_LUMINANCE")
                         ", "
                         (code "GL_LUMINANCE4")
                         ", "
                         (code "GL_LUMINANCE8")
                         ", "
                         (code "GL_LUMINANCE12")
                         ", "
                         (code "GL_LUMINANCE16")
                         ", "
                         (code "GL_LUMINANCE_ALPHA")
                         ", "
                         (code "GL_LUMINANCE4_ALPHA4")
                         ", "
                         (code "GL_LUMINANCE6_ALPHA2")
                         ", "
                         (code "GL_LUMINANCE8_ALPHA8")
                         ", "
                         (code "GL_LUMINANCE12_ALPHA4")
                         ", "
                         (code "GL_LUMINANCE12_ALPHA12")
                         ", "
                         (code "GL_LUMINANCE16_ALPHA16")
                         ", "
                         (code "GL_INTENSITY")
                         ", "
                         (code "GL_INTENSITY4")
                         ", "
                         (code "GL_INTENSITY8")
                         ", "
                         (code "GL_INTENSITY12")
                         ", "
                         (code "GL_INTENSITY16")
                         ", "
                         (code "GL_R3_G3_B2")
                         ", "
                         (code "GL_RGB")
                         ", "
                         (code "GL_RGB4")
                         ", "
                         (code "GL_RGB5")
                         ", "
                         (code "GL_RGB8")
                         ", "
                         (code "GL_RGB10")
                         ", "
                         (code "GL_RGB12")
                         ", "
                         (code "GL_RGB16")
                         ", "
                         (code "GL_RGBA")
                         ", "
                         (code "GL_RGBA2")
                         ", "
                         (code "GL_RGBA4")
                         ", "
                         (code "GL_RGB5_A1")
                         ", "
                         (code "GL_RGBA8")
                         ", "
                         (code "GL_RGB10_A2")
                         ", "
                         (code "GL_RGBA12")
                         ", or "
                         (code "GL_RGBA16")
                         ". "))
            (entry (% (heading (var "width")))
                   (para "
The width of the pixel array referenced by "
                         (var "data")
                         ". "))
            (entry (% (heading (var "height")))
                   (para "
The height of the pixel array referenced by "
                         (var "data")
                         ". "))
            (entry (% (heading (var "format")))
                   (para "
The format of the pixel data in "
                         (var "data")
                         ".
                    The allowable values are "
                         (code "GL_RED")
                         ", "
                         (code "GL_GREEN")
                         ", "
                         (code "GL_BLUE")
                         ", "
                         (code "GL_ALPHA")
                         ", "
                         (code "GL_RGB")
                         ", "
                         (code "GL_BGR")
                         ", "
                         (code "GL_RGBA")
                         ", "
                         (code "GL_BGRA")
                         ", "
                         (code "GL_LUMINANCE")
                         ", and "
                         (code "GL_LUMINANCE_ALPHA")
                         ". "))
            (entry (% (heading (var "type")))
                   (para "
The type of the pixel data in "
                         (var "data")
                         ".
                    Symbolic constants "
                         (code "GL_UNSIGNED_BYTE")
                         ", "
                         (code "GL_BYTE")
                         ", "
                         (code "GL_BITMAP")
                         ", "
                         (code "GL_UNSIGNED_SHORT")
                         ", "
                         (code "GL_SHORT")
                         ", "
                         (code "GL_UNSIGNED_INT")
                         ", "
                         (code "GL_INT")
                         ", "
                         (code "GL_FLOAT")
                         ", "
                         (code "GL_UNSIGNED_BYTE_3_3_2")
                         ", "
                         (code "GL_UNSIGNED_BYTE_2_3_3_REV")
                         ", "
                         (code "GL_UNSIGNED_SHORT_5_6_5")
                         ", "
                         (code "GL_UNSIGNED_SHORT_5_6_5_REV")
                         ", "
                         (code "GL_UNSIGNED_SHORT_4_4_4_4")
                         ", "
                         (code "GL_UNSIGNED_SHORT_4_4_4_4_REV")
                         ", "
                         (code "GL_UNSIGNED_SHORT_5_5_5_1")
                         ", "
                         (code "GL_UNSIGNED_SHORT_1_5_5_5_REV")
                         ", "
                         (code "GL_UNSIGNED_INT_8_8_8_8")
                         ", "
                         (code "GL_UNSIGNED_INT_8_8_8_8_REV")
                         ", "
                         (code "GL_UNSIGNED_INT_10_10_10_2")
                         ", and "
                         (code "GL_UNSIGNED_INT_2_10_10_10_REV")
                         "
are accepted. "))
            (entry (% (heading (var "data")))
                   (para "
Pointer to a two-dimensional array of pixel data that is processed to
                    build the convolution filter kernel. ")))
     (heading "Description")
     (para (code "glConvolutionFilter2D")
           " builds a two-dimensional convolution filter kernel from an array of
            pixels. ")
     (para "
The pixel array specified by "
           (var "width")
           ", "
           (var "height")
           ", "
           (var "format")
           ", "
           (var "type")
           ", and "
           (var "data")
           " is extracted from memory and processed just as if "
           (code "glDrawPixels")
           " were called, but processing stops after the final
            expansion to RGBA is completed. ")
     (para "
If a non-zero named buffer object is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target 
            (see "
           (code "glBindBuffer")
           ") while a convolution filter is
            specified, "
           (var "data")
           " is treated as a byte offset into the buffer object's data store. ")
     (para "
The R, G, B, and A components of each pixel are next scaled by the four
            2D "
           (code "GL_CONVOLUTION_FILTER_SCALE")
           " parameters and biased by the
            four 2D "
           (code "GL_CONVOLUTION_FILTER_BIAS")
           " parameters.
            (The scale and bias parameters are set by "
           (code "glConvolutionParameter")
           "
using the "
           (code "GL_CONVOLUTION_2D")
           " target and the names "
           (code "GL_CONVOLUTION_FILTER_SCALE")
           " and "
           (code "GL_CONVOLUTION_FILTER_BIAS")
           ".
            The parameters themselves are vectors of four values that are applied to red,
            green, blue, and alpha, in that order.)
            The R, G, B, and A values are not clamped to [0,1] at any time during this
            process. ")
     (para "
Each pixel is then converted to the internal format specified by "
           (var "internalformat")
           ".
            This conversion simply maps the component values of the pixel (R, G, B,
            and A) to the values included in the internal format (red, green, blue,
            alpha, luminance, and intensity).  The mapping is as follows: ")
     (para)
     (table (% (formatter (asis)))
            (entry (% (heading (strong "Internal Format")))
                   (para (strong "Red")
                         ", "
                         (strong "Green")
                         ", "
                         (strong "Blue")
                         ", "
                         (strong "Alpha")
                         ", "
                         (strong "Luminance")
                         ", "
                         (strong "Intensity")))
            (entry (% (heading (code "GL_ALPHA")))
                   (para ", " ", " ", " "
A " ", " ", "))
            (entry (% (heading (code "GL_LUMINANCE")))
                   (para ", " ", " ", " ", " "
R " ", "))
            (entry (% (heading (code "GL_LUMINANCE_ALPHA")))
                   (para ", " ", " ", " "
A " ", " "
R " ", "))
            (entry (% (heading (code "GL_INTENSITY")))
                   (para ", " ", " ", " ", " ", " "
R "))
            (entry (% (heading (code "GL_RGB")))
                   (para "
R " ", " "
G " ", " "
B " ", " ", " ", "))
            (entry (% (heading (code "GL_RGBA")))
                   (para "
R "
                         ", "
                         "
G "
                         ", "
                         "
B "
                         ", "
                         "
A "
                         ", "
                         ", ")))
     (para "
The red, green, blue, alpha, luminance, and/or intensity components of
            the resulting pixels are stored in floating-point rather than integer
            format.
            They form a two-dimensional filter kernel image indexed with coordinates "
           (var "i")
           " and "
           (var "j")
           " such that "
           (var "i")
           " starts at zero and increases from left
            to right, and "
           (var "j")
           " starts at zero and increases from bottom to top.
            Kernel location "
           (var "i,j")
           " is derived from the "
           (var "N")
           "th pixel,
            where "
           (var "N")
           " is "
           (var "i")
           "+"
           (var "j")
           "*"
           (var "width")
           ". ")
     (para "
Note that after a convolution is performed, the resulting color
            components are also scaled by their corresponding "
           (code "GL_POST_CONVOLUTION_c_SCALE")
           " parameters and biased by their
            corresponding "
           (code "GL_POST_CONVOLUTION_c_BIAS")
           " parameters (where "
           (var "c")
           " takes on the values "
           (strong "RED")
           ", "
           (strong "GREEN")
           ", "
           (strong "BLUE")
           ", and "
           (strong "ALPHA")
           ").
            These parameters are set by "
           (code "glPixelTransfer")
           ". ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "target")
           " is not "
           (code "GL_CONVOLUTION_2D")
           ". ")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "internalformat")
           " is not one of the
            allowable values. ")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "format")
           " is not one of the allowable
            values. ")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "type")
           " is not one of the allowable
            values. ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "width")
           " is less than zero or greater
            than the maximum supported value.
            This value may be queried with "
           (code "glGetConvolutionParameter")
           "
using target "
           (code "GL_CONVOLUTION_2D")
           " and name "
           (code "GL_MAX_CONVOLUTION_WIDTH")
           ". ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "height")
           " is less than zero or greater
            than the maximum supported value.
            This value may be queried with "
           (code "glGetConvolutionParameter")
           "
using target "
           (code "GL_CONVOLUTION_2D")
           " and name "
           (code "GL_MAX_CONVOLUTION_HEIGHT")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (var "height")
           " is one of "
           (code "GL_UNSIGNED_BYTE_3_3_2")
           ", "
           (code "GL_UNSIGNED_BYTE_2_3_3_REV")
           ", "
           (code "GL_UNSIGNED_SHORT_5_6_5")
           ", or "
           (code "GL_UNSIGNED_SHORT_5_6_5_REV")
           "
and "
           (var "format")
           " is not "
           (code "GL_RGB")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (var "height")
           " is one of "
           (code "GL_UNSIGNED_SHORT_4_4_4_4")
           ", "
           (code "GL_UNSIGNED_SHORT_4_4_4_4_REV")
           ", "
           (code "GL_UNSIGNED_SHORT_5_5_5_1")
           ", "
           (code "GL_UNSIGNED_SHORT_1_5_5_5_REV")
           ", "
           (code "GL_UNSIGNED_INT_8_8_8_8")
           ", "
           (code "GL_UNSIGNED_INT_8_8_8_8_REV")
           ", "
           (code "GL_UNSIGNED_INT_10_10_10_2")
           ", or "
           (code "GL_UNSIGNED_INT_2_10_10_10_REV")
           "
and "
           (var "format")
           " is neither "
           (code "GL_RGBA")
           " nor "
           (code "GL_BGRA")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target and the buffer object's data store is currently mapped. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target and the data would be unpacked from the buffer 
            object such that the memory reads required would exceed the data store size. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target and "
           (var "data")
           " is not evenly divisible 
            into the number of bytes needed to store in memory a datum indicated by "
           (var "type")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glConvolutionFilter2D")
           " is executed
            between the execution of "
           (code "glBegin")
           " and the corresponding
            execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glConvolutionParameter
  "glConvolutionParameter"
  (funcsynopsis
    (funcprototype
      (funcdef
        "void "
        (function "glConvolutionParameterf"))
      (paramdef "GLenum " (parameter "target"))
      (paramdef "GLenum " (parameter "pname"))
      (paramdef "GLfloat " (parameter "params"))))
  '(*fragment*
     (heading "set convolution parameters")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "target")))
                   (para "
The target for the convolution parameter.
                    Must be one of "
                         (code "GL_CONVOLUTION_1D")
                         ", "
                         (code "GL_CONVOLUTION_2D")
                         ", or "
                         (code "GL_SEPARABLE_2D")
                         ". "))
            (entry (% (heading (var "pname")))
                   (para "
The parameter to be set.
                    Must be "
                         (code "GL_CONVOLUTION_BORDER_MODE")
                         ". "))
            (entry (% (heading (var "params")))
                   (para "
The parameter value.
                    Must be one of "
                         (code "GL_REDUCE")
                         ", "
                         (code "GL_CONSTANT_BORDER")
                         ", "
                         (code "GL_REPLICATE_BORDER")
                         ". ")
                   (para)))
     (heading "Description")
     (para (code "glConvolutionParameter")
           " sets the value of a convolution parameter. ")
     (para (var "target")
           " selects the convolution filter to be affected: "
           (code "GL_CONVOLUTION_1D")
           ", "
           (code "GL_CONVOLUTION_2D")
           ", or "
           (code "GL_SEPARABLE_2D")
           "
for the 1D, 2D, or separable 2D filter, respectively. ")
     (para (var "pname")
           " selects the parameter to be changed. "
           (code "GL_CONVOLUTION_FILTER_SCALE")
           " and "
           (code "GL_CONVOLUTION_FILTER_BIAS")
           "
affect the definition of the convolution filter kernel; see "
           (code "glConvolutionFilter1D")
           ", "
           (code "glConvolutionFilter2D")
           ", and "
           (code "glSeparableFilter2D")
           " for details.
            In these cases, "
           (var "params")
           "v is an array of four values to be applied to
            red, green, blue, and alpha values, respectively. The initial value for "
           (code "GL_CONVOLUTION_FILTER_SCALE")
           " is (1, 1, 1, 1), and the initial value
            for "
           (code "GL_CONVOLUTION_FILTER_BIAS")
           " is (0, 0, 0, 0). ")
     (para "
A "
           (var "pname")
           " value of "
           (code "GL_CONVOLUTION_BORDER_MODE")
           " controls the
            convolution border mode. The accepted modes are: ")
     (table (% (formatter (asis)))
            (entry (% (heading (code "GL_REDUCE")))
                   (para "
The image resulting from convolution is
                        smaller than the source image.
                        If the filter width is "
                         (math (var "Wf"))
                         "
and height is "
                         (math (var "Hf"))
                         ",
                        and the source image width is "
                         (math (var "Ws"))
                         "
and height is "
                         (math (var "Hs"))
                         ",
                        then the convolved image width will be "
                         (math (var "Ws") "-" (var "Wf") "+" "1")
                         "
and height
                        will be "
                         (math (var "Hs") "-" (var "Hf") "+" "1")
                         ".
                        (If this reduction would generate an image with zero or negative width
                        and/or height, the output is simply null, with no error generated.)
                        The coordinates of the image resulting from convolution are zero
                        through "
                         (math (var "Ws") "-" (var "Wf"))
                         "
in width and zero through "
                         (math (var "Hs") "-" (var "Hf"))
                         "
in
                        height. "))
            (entry (% (heading (code "GL_CONSTANT_BORDER")))
                   (para "
The image resulting from convolution is the same size as the source image, and
                        processed as if the source image were surrounded by pixels with their color
                        specified by the "
                         (code "GL_CONVOLUTION_BORDER_COLOR")
                         ". "))
            (entry (% (heading (code "GL_REPLICATE_BORDER")))
                   (para "
The image resulting from convolution is the same size as the source image, and
                        processed as if the outermost pixel on the border of the source image were
                        replicated. ")))
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "target")
           " is not one of the allowable
            values. ")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "pname")
           " is not one of the allowable
            values. ")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "pname")
           " is "
           (code "GL_CONVOLUTION_BORDER_MODE")
           " and "
           (var "params")
           " is not one of "
           (code "GL_REDUCE")
           ", "
           (code "GL_CONSTANT_BORDER")
           ", or "
           (code "GL_REPLICATE_BORDER")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glConvolutionParameter")
           " is executed
            between the execution of "
           (code "glBegin")
           " and the corresponding
            execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glCopyColorSubTable
  "glCopyColorSubTable"
  (funcsynopsis
    (funcprototype
      (funcdef
        "void "
        (function "glCopyColorSubTable"))
      (paramdef "GLenum " (parameter "target"))
      (paramdef "GLsizei " (parameter "start"))
      (paramdef "GLint " (parameter "x"))
      (paramdef "GLint " (parameter "y"))
      (paramdef "GLsizei " (parameter "width"))))
  '(*fragment*
     (heading "respecify a portion of a color table")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "target")))
                   (para "
Must be one of "
                         (code "GL_COLOR_TABLE")
                         ", "
                         (code "GL_POST_CONVOLUTION_COLOR_TABLE")
                         ", or "
                         (code "GL_POST_COLOR_MATRIX_COLOR_TABLE")
                         ". "))
            (entry (% (heading (var "start")))
                   (para "
The starting index of the portion of the color table to be replaced. "))
            (entry (% (heading (var "x")))
                   (itemx (var "y"))
                   (para "
The window coordinates of the left corner of the row of pixels to be
                    copied. "))
            (entry (% (heading (var "width")))
                   (para "
The number of table entries to replace. ")))
     (heading "Description")
     (para (code "glCopyColorSubTable")
           " is used to respecify a contiguous portion of a color table previously
            defined using "
           (code "glColorTable")
           ".  The pixels copied from the framebuffer
            replace the portion of the existing table from indices "
           (var "start")
           " to "
           (math (var "start") "+" (var "x") "-" "1")
           ",
            inclusive.  This region may not include any
            entries outside the range of the color table, as was originally specified.
            It is not an error to specify a subtexture with width of 0, but such a
            specification has no effect. ")
     (heading "Errors")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "target")
           " is not a previously defined
            color table. ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "target")
           " is not one of the allowable
            values. ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (math (var "start")
                 "+"
                 (var "x")
                 ">"
                 (var "width"))
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glCopyColorSubTable")
           " is executed
            between the execution of "
           (code "glBegin")
           " and the corresponding
            execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glCopyColorTable
  "glCopyColorTable"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glCopyColorTable"))
      (paramdef "GLenum " (parameter "target"))
      (paramdef "GLenum " (parameter "internalformat"))
      (paramdef "GLint " (parameter "x"))
      (paramdef "GLint " (parameter "y"))
      (paramdef "GLsizei " (parameter "width"))))
  '(*fragment*
     (heading "copy pixels into a color table")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "target")))
                   (para "
The color table target. Must be "
                         (code "GL_COLOR_TABLE")
                         ", "
                         (code "GL_POST_CONVOLUTION_COLOR_TABLE")
                         ",
                    or "
                         (code "GL_POST_COLOR_MATRIX_COLOR_TABLE")
                         ". "))
            (entry (% (heading (var "internalformat")))
                   (para "
The internal storage format of the texture image.
                    Must be one of the following symbolic constants: "
                         (code "GL_ALPHA")
                         ", "
                         (code "GL_ALPHA4")
                         ", "
                         (code "GL_ALPHA8")
                         ", "
                         (code "GL_ALPHA12")
                         ", "
                         (code "GL_ALPHA16")
                         ", "
                         (code "GL_LUMINANCE")
                         ", "
                         (code "GL_LUMINANCE4")
                         ", "
                         (code "GL_LUMINANCE8")
                         ", "
                         (code "GL_LUMINANCE12")
                         ", "
                         (code "GL_LUMINANCE16")
                         ", "
                         (code "GL_LUMINANCE_ALPHA")
                         ", "
                         (code "GL_LUMINANCE4_ALPHA4")
                         ", "
                         (code "GL_LUMINANCE6_ALPHA2")
                         ", "
                         (code "GL_LUMINANCE8_ALPHA8")
                         ", "
                         (code "GL_LUMINANCE12_ALPHA4")
                         ", "
                         (code "GL_LUMINANCE12_ALPHA12")
                         ", "
                         (code "GL_LUMINANCE16_ALPHA16")
                         ", "
                         (code "GL_INTENSITY")
                         ", "
                         (code "GL_INTENSITY4")
                         ", "
                         (code "GL_INTENSITY8")
                         ", "
                         (code "GL_INTENSITY12")
                         ", "
                         (code "GL_INTENSITY16")
                         ", "
                         (code "GL_R3_G3_B2")
                         ", "
                         (code "GL_RGB")
                         ", "
                         (code "GL_RGB4")
                         ", "
                         (code "GL_RGB5")
                         ", "
                         (code "GL_RGB8")
                         ", "
                         (code "GL_RGB10")
                         ", "
                         (code "GL_RGB12")
                         ", "
                         (code "GL_RGB16")
                         ", "
                         (code "GL_RGBA")
                         ", "
                         (code "GL_RGBA2")
                         ", "
                         (code "GL_RGBA4")
                         ", "
                         (code "GL_RGB5_A1")
                         ", "
                         (code "GL_RGBA8")
                         ", "
                         (code "GL_RGB10_A2")
                         ", "
                         (code "GL_RGBA12")
                         ", or "
                         (code "GL_RGBA16")
                         ". "))
            (entry (% (heading (var "x")))
                   (para "
The x coordinate of the lower-left corner of the pixel rectangle
                    to be transferred to the color table. "))
            (entry (% (heading (var "y")))
                   (para "
The y coordinate of the lower-left corner of the pixel rectangle
                    to be transferred to the color table. "))
            (entry (% (heading (var "width")))
                   (para "
The width of the pixel rectangle. ")))
     (heading "Description")
     (para (code "glCopyColorTable")
           " loads a color table with pixels from the current "
           (code "GL_READ_BUFFER")
           " (rather than from main memory, as is the case for "
           (code "glColorTable")
           "). ")
     (para "
The screen-aligned pixel rectangle with lower-left corner at ("
           (var "x")
           ",\\ "
           (var "y")
           ")
            having width "
           (var "width")
           " and height 1
            is loaded into the color table. If any pixels within
            this region are outside the window that is associated with the GL
            context, the values obtained for those pixels are undefined. ")
     (para "
The pixels in the rectangle are processed just as if "
           (code "glReadPixels")
           " were called, with "
           (var "internalformat")
           " set to RGBA,
            but processing stops after the final conversion to RGBA. ")
     (para "
The four scale parameters and the four bias parameters that are defined
            for the table are then used to scale and bias the R, G, B, and A components
            of each pixel. The scale and bias parameters are set by calling "
           (code "glColorTableParameter")
           ". ")
     (para "
Next, the R, G, B, and A values are clamped to the range "
           (math "[" "0" "," "1" "]")
           ".
            Each pixel is then converted to the internal format specified by "
           (var "internalformat")
           ". This conversion simply maps the component values of the pixel (R, G, B,
            and A) to the values included in the internal format (red, green, blue,
            alpha, luminance, and intensity).  The mapping is as follows: ")
     (para)
     (table (% (formatter (asis)))
            (entry (% (heading (strong "Internal Format")))
                   (para (strong "Red")
                         ", "
                         (strong "Green")
                         ", "
                         (strong "Blue")
                         ", "
                         (strong "Alpha")
                         ", "
                         (strong "Luminance")
                         ", "
                         (strong "Intensity")))
            (entry (% (heading (code "GL_ALPHA")))
                   (para ", " ", " ", " "
A " ", " ", "))
            (entry (% (heading (code "GL_LUMINANCE")))
                   (para ", " ", " ", " ", " "
R " ", "))
            (entry (% (heading (code "GL_LUMINANCE_ALPHA")))
                   (para ", " ", " ", " "
A " ", " "
R " ", "))
            (entry (% (heading (code "GL_INTENSITY")))
                   (para ", " ", " ", " ", " ", " "
R "))
            (entry (% (heading (code "GL_RGB")))
                   (para "
R " ", " "
G " ", " "
B " ", " ", " ", "))
            (entry (% (heading (code "GL_RGBA")))
                   (para "
R "
                         ", "
                         "
G "
                         ", "
                         "
B "
                         ", "
                         "
A "
                         ", "
                         ", ")))
     (para "
Finally, the red, green, blue, alpha, luminance, and/or intensity components of
            the resulting pixels are stored in the color table.
            They form a one-dimensional table with indices in the range "
           (math "[" "0" "," (var "width") "-" "1" "]")
           ". ")
     (para)
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated when "
           (var "target")
           " is not one of the
            allowable values. ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "width")
           " is less than zero. ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "internalformat")
           " is not one of the
            allowable values. ")
     (para (code "GL_TABLE_TOO_LARGE")
           " is generated if the requested color table
            is too large to be supported by the implementation. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glCopyColorTable")
           " is executed
            between the execution of "
           (code "glBegin")
           " and the corresponding
            execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glCopyConvolutionFilter1D
  "glCopyConvolutionFilter1D"
  (funcsynopsis
    (funcprototype
      (funcdef
        "void "
        (function "glCopyConvolutionFilter1D"))
      (paramdef "GLenum " (parameter "target"))
      (paramdef "GLenum " (parameter "internalformat"))
      (paramdef "GLint " (parameter "x"))
      (paramdef "GLint " (parameter "y"))
      (paramdef "GLsizei " (parameter "width"))))
  '(*fragment*
     (heading
       "copy pixels into a one-dimensional convolution filter")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "target")))
                   (para "
Must be "
                         (code "GL_CONVOLUTION_1D")
                         ". "))
            (entry (% (heading (var "internalformat")))
                   (para "
The internal format of the convolution filter kernel.
                    The allowable values are "
                         (code "GL_ALPHA")
                         ", "
                         (code "GL_ALPHA4")
                         ", "
                         (code "GL_ALPHA8")
                         ", "
                         (code "GL_ALPHA12")
                         ", "
                         (code "GL_ALPHA16")
                         ", "
                         (code "GL_LUMINANCE")
                         ", "
                         (code "GL_LUMINANCE4")
                         ", "
                         (code "GL_LUMINANCE8")
                         ", "
                         (code "GL_LUMINANCE12")
                         ", "
                         (code "GL_LUMINANCE16")
                         ", "
                         (code "GL_LUMINANCE_ALPHA")
                         ", "
                         (code "GL_LUMINANCE4_ALPHA4")
                         ", "
                         (code "GL_LUMINANCE6_ALPHA2")
                         ", "
                         (code "GL_LUMINANCE8_ALPHA8")
                         ", "
                         (code "GL_LUMINANCE12_ALPHA4")
                         ", "
                         (code "GL_LUMINANCE12_ALPHA12")
                         ", "
                         (code "GL_LUMINANCE16_ALPHA16")
                         ", "
                         (code "GL_INTENSITY")
                         ", "
                         (code "GL_INTENSITY4")
                         ", "
                         (code "GL_INTENSITY8")
                         ", "
                         (code "GL_INTENSITY12")
                         ", "
                         (code "GL_INTENSITY16")
                         ", "
                         (code "GL_R3_G3_B2")
                         ", "
                         (code "GL_RGB")
                         ", "
                         (code "GL_RGB4")
                         ", "
                         (code "GL_RGB5")
                         ", "
                         (code "GL_RGB8")
                         ", "
                         (code "GL_RGB10")
                         ", "
                         (code "GL_RGB12")
                         ", "
                         (code "GL_RGB16")
                         ", "
                         (code "GL_RGBA")
                         ", "
                         (code "GL_RGBA2")
                         ", "
                         (code "GL_RGBA4")
                         ", "
                         (code "GL_RGB5_A1")
                         ", "
                         (code "GL_RGBA8")
                         ", "
                         (code "GL_RGB10_A2")
                         ", "
                         (code "GL_RGBA12")
                         ", or "
                         (code "GL_RGBA16")
                         ". "))
            (entry (% (heading (var "x")))
                   (itemx (var "y"))
                   (para "
The window space coordinates of the lower-left coordinate of the
                    pixel array to copy. "))
            (entry (% (heading (var "width")))
                   (para "
The width of the pixel array to copy. ")))
     (heading "Description")
     (para (code "glCopyConvolutionFilter1D")
           " defines a one-dimensional convolution filter kernel with pixels
            from the current "
           (code "GL_READ_BUFFER")
           " (rather than from main memory,
            as is the case for "
           (code "glConvolutionFilter1D")
           "). ")
     (para "
The screen-aligned pixel rectangle with lower-left corner at ("
           (var "x")
           ",\\ "
           (var "y")
           "),
            width "
           (var "width")
           " and height 1 is used to define
            the convolution filter.  If any pixels within this region are
            outside the window that is associated with the GL context, the
            values obtained for those pixels are undefined. ")
     (para "
The pixels in the rectangle are processed exactly as if "
           (code "glReadPixels")
           "
had been called with "
           (var "format")
           "
set to RGBA, but the process stops just before final conversion.
            The R, G, B, and A components of each pixel are next scaled by the four
            1D "
           (code "GL_CONVOLUTION_FILTER_SCALE")
           " parameters and biased by the
            four 1D "
           (code "GL_CONVOLUTION_FILTER_BIAS")
           " parameters.
            (The scale and bias parameters are set by "
           (code "glConvolutionParameter")
           "
using the "
           (code "GL_CONVOLUTION_1D")
           " target and the names "
           (code "GL_CONVOLUTION_FILTER_SCALE")
           " and "
           (code "GL_CONVOLUTION_FILTER_BIAS")
           ".
            The parameters themselves are vectors of four values that are applied to red,
            green, blue, and alpha, in that order.)
            The R, G, B, and A values are not clamped to [0,1] at any time during this
            process. ")
     (para "
Each pixel is then converted to the internal format specified by "
           (var "internalformat")
           ".
            This conversion simply maps the component values of the pixel (R, G, B,
            and A) to the values included in the internal format (red, green, blue,
            alpha, luminance, and intensity).  The mapping is as follows: ")
     (para)
     (table (% (formatter (asis)))
            (entry (% (heading (strong "Internal Format")))
                   (para (strong "Red")
                         ", "
                         (strong "Green")
                         ", "
                         (strong "Blue")
                         ", "
                         (strong "Alpha")
                         ", "
                         (strong "Luminance")
                         ", "
                         (strong "Intensity")))
            (entry (% (heading (code "GL_ALPHA")))
                   (para ", " ", " ", " "
A " ", " ", "))
            (entry (% (heading (code "GL_LUMINANCE")))
                   (para ", " ", " ", " ", " "
R " ", "))
            (entry (% (heading (code "GL_LUMINANCE_ALPHA")))
                   (para ", " ", " ", " "
A " ", " "
R " ", "))
            (entry (% (heading (code "GL_INTENSITY")))
                   (para ", " ", " ", " ", " ", " "
R "))
            (entry (% (heading (code "GL_RGB")))
                   (para "
R " ", " "
G " ", " "
B " ", " ", " ", "))
            (entry (% (heading (code "GL_RGBA")))
                   (para "
R "
                         ", "
                         "
G "
                         ", "
                         "
B "
                         ", "
                         "
A "
                         ", "
                         ", ")))
     (para "
The red, green, blue, alpha, luminance, and/or intensity components of
            the resulting pixels are stored in floating-point rather than integer
            format. ")
     (para "
Pixel ordering is such that lower x screen coordinates correspond to
            lower "
           (var "i")
           " filter image coordinates. ")
     (para "
Note that after a convolution is performed, the resulting color
            components are also scaled by their corresponding "
           (code "GL_POST_CONVOLUTION_c_SCALE")
           " parameters and biased by their
            corresponding "
           (code "GL_POST_CONVOLUTION_c_BIAS")
           " parameters (where "
           (var "c")
           " takes on the values "
           (strong "RED")
           ", "
           (strong "GREEN")
           ", "
           (strong "BLUE")
           ", and "
           (strong "ALPHA")
           ").
            These parameters are set by "
           (code "glPixelTransfer")
           ". ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "target")
           " is not "
           (code "GL_CONVOLUTION_1D")
           ". ")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "internalformat")
           " is not one of the
            allowable values. ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "width")
           " is less than zero or greater
            than the maximum supported value.
            This value may be queried with "
           (code "glGetConvolutionParameter")
           "
using target "
           (code "GL_CONVOLUTION_1D")
           " and name "
           (code "GL_MAX_CONVOLUTION_WIDTH")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glCopyConvolutionFilter1D")
           " is executed
            between the execution of "
           (code "glBegin")
           " and the corresponding
            execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glCopyConvolutionFilter2D
  "glCopyConvolutionFilter2D"
  (funcsynopsis
    (funcprototype
      (funcdef
        "void "
        (function "glCopyConvolutionFilter2D"))
      (paramdef "GLenum " (parameter "target"))
      (paramdef "GLenum " (parameter "internalformat"))
      (paramdef "GLint " (parameter "x"))
      (paramdef "GLint " (parameter "y"))
      (paramdef "GLsizei " (parameter "width"))
      (paramdef "GLsizei " (parameter "height"))))
  '(*fragment*
     (heading
       "copy pixels into a two-dimensional convolution filter")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "target")))
                   (para "
Must be "
                         (code "GL_CONVOLUTION_2D")
                         ". "))
            (entry (% (heading (var "internalformat")))
                   (para "
The internal format of the convolution filter kernel.
                    The allowable values are "
                         (code "GL_ALPHA")
                         ", "
                         (code "GL_ALPHA4")
                         ", "
                         (code "GL_ALPHA8")
                         ", "
                         (code "GL_ALPHA12")
                         ", "
                         (code "GL_ALPHA16")
                         ", "
                         (code "GL_LUMINANCE")
                         ", "
                         (code "GL_LUMINANCE4")
                         ", "
                         (code "GL_LUMINANCE8")
                         ", "
                         (code "GL_LUMINANCE12")
                         ", "
                         (code "GL_LUMINANCE16")
                         ", "
                         (code "GL_LUMINANCE_ALPHA")
                         ", "
                         (code "GL_LUMINANCE4_ALPHA4")
                         ", "
                         (code "GL_LUMINANCE6_ALPHA2")
                         ", "
                         (code "GL_LUMINANCE8_ALPHA8")
                         ", "
                         (code "GL_LUMINANCE12_ALPHA4")
                         ", "
                         (code "GL_LUMINANCE12_ALPHA12")
                         ", "
                         (code "GL_LUMINANCE16_ALPHA16")
                         ", "
                         (code "GL_INTENSITY")
                         ", "
                         (code "GL_INTENSITY4")
                         ", "
                         (code "GL_INTENSITY8")
                         ", "
                         (code "GL_INTENSITY12")
                         ", "
                         (code "GL_INTENSITY16")
                         ", "
                         (code "GL_R3_G3_B2")
                         ", "
                         (code "GL_RGB")
                         ", "
                         (code "GL_RGB4")
                         ", "
                         (code "GL_RGB5")
                         ", "
                         (code "GL_RGB8")
                         ", "
                         (code "GL_RGB10")
                         ", "
                         (code "GL_RGB12")
                         ", "
                         (code "GL_RGB16")
                         ", "
                         (code "GL_RGBA")
                         ", "
                         (code "GL_RGBA2")
                         ", "
                         (code "GL_RGBA4")
                         ", "
                         (code "GL_RGB5_A1")
                         ", "
                         (code "GL_RGBA8")
                         ", "
                         (code "GL_RGB10_A2")
                         ", "
                         (code "GL_RGBA12")
                         ", or "
                         (code "GL_RGBA16")
                         ". "))
            (entry (% (heading (var "x")))
                   (itemx (var "y"))
                   (para "
The window space coordinates of the lower-left coordinate of the
                    pixel array to copy. "))
            (entry (% (heading (var "width")))
                   (para "
The width of the pixel array to copy. "))
            (entry (% (heading (var "height")))
                   (para "
The height of the pixel array to copy. ")))
     (heading "Description")
     (para (code "glCopyConvolutionFilter2D")
           " defines a two-dimensional convolution filter kernel with pixels
            from the current "
           (code "GL_READ_BUFFER")
           " (rather than from main memory,
            as is the case for "
           (code "glConvolutionFilter2D")
           "). ")
     (para "
The screen-aligned pixel rectangle with lower-left corner at ("
           (var "x")
           ",\\ "
           (var "y")
           "),
            width "
           (var "width")
           " and height "
           (var "height")
           "
is used to define the convolution filter. If any pixels within this
            region are
            outside the window that is associated with the GL context, the
            values obtained for those pixels are undefined. ")
     (para "
The pixels in the rectangle are processed
            exactly as if "
           (code "glReadPixels")
           " had been called with "
           (var "format")
           "
set to RGBA, but the process stops just before final conversion.
            The R, G, B, and A components of each pixel are next scaled by the four
            2D "
           (code "GL_CONVOLUTION_FILTER_SCALE")
           " parameters and biased by the
            four 2D "
           (code "GL_CONVOLUTION_FILTER_BIAS")
           " parameters.
            (The scale and bias parameters are set by "
           (code "glConvolutionParameter")
           "
using the "
           (code "GL_CONVOLUTION_2D")
           " target and the names "
           (code "GL_CONVOLUTION_FILTER_SCALE")
           " and "
           (code "GL_CONVOLUTION_FILTER_BIAS")
           ".
            The parameters themselves are vectors of four values that are applied to red,
            green, blue, and alpha, in that order.)
            The R, G, B, and A values are not clamped to [0,1] at any time during this
            process. ")
     (para "
Each pixel is then converted to the internal format specified by "
           (var "internalformat")
           ".
            This conversion simply maps the component values of the pixel (R, G, B,
            and A) to the values included in the internal format (red, green, blue,
            alpha, luminance, and intensity).  The mapping is as follows: ")
     (para)
     (table (% (formatter (asis)))
            (entry (% (heading (strong "Internal Format")))
                   (para (strong "Red")
                         ", "
                         (strong "Green")
                         ", "
                         (strong "Blue")
                         ", "
                         (strong "Alpha")
                         ", "
                         (strong "Luminance")
                         ", "
                         (strong "Intensity")))
            (entry (% (heading (code "GL_ALPHA")))
                   (para ", " ", " ", " "
A " ", " ", "))
            (entry (% (heading (code "GL_LUMINANCE")))
                   (para ", " ", " ", " ", " "
R " ", "))
            (entry (% (heading (code "GL_LUMINANCE_ALPHA")))
                   (para ", " ", " ", " "
A " ", " "
R " ", "))
            (entry (% (heading (code "GL_INTENSITY")))
                   (para ", " ", " ", " ", " ", " "
R "))
            (entry (% (heading (code "GL_RGB")))
                   (para "
R " ", " "
G " ", " "
B " ", " ", " ", "))
            (entry (% (heading (code "GL_RGBA")))
                   (para "
R "
                         ", "
                         "
G "
                         ", "
                         "
B "
                         ", "
                         "
A "
                         ", "
                         ", ")))
     (para "
The red, green, blue, alpha, luminance, and/or intensity components of
            the resulting pixels are stored in floating-point rather than integer
            format. ")
     (para "
Pixel ordering is such that lower x screen coordinates correspond to
            lower "
           (var "i")
           " filter image coordinates, and lower y screen coordinates
            correspond to lower "
           (var "j")
           " filter image coordinates. ")
     (para "
Note that after a convolution is performed, the resulting color
            components are also scaled by their corresponding "
           (code "GL_POST_CONVOLUTION_c_SCALE")
           " parameters and biased by their
            corresponding "
           (code "GL_POST_CONVOLUTION_c_BIAS")
           " parameters (where "
           (var "c")
           " takes on the values "
           (strong "RED")
           ", "
           (strong "GREEN")
           ", "
           (strong "BLUE")
           ", and "
           (strong "ALPHA")
           ").
            These parameters are set by "
           (code "glPixelTransfer")
           ". ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "target")
           " is not "
           (code "GL_CONVOLUTION_2D")
           ". ")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "internalformat")
           " is not one of the
            allowable values. ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "width")
           " is less than zero or greater
            than the maximum supported value.
            This value may be queried with "
           (code "glGetConvolutionParameter")
           "
using target "
           (code "GL_CONVOLUTION_2D")
           " and name "
           (code "GL_MAX_CONVOLUTION_WIDTH")
           ". ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "height")
           " is less than zero or greater
            than the maximum supported value.
            This value may be queried with "
           (code "glGetConvolutionParameter")
           "
using target "
           (code "GL_CONVOLUTION_2D")
           " and name "
           (code "GL_MAX_CONVOLUTION_HEIGHT")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glCopyConvolutionFilter2D")
           " is executed
            between the execution of "
           (code "glBegin")
           " and the corresponding
            execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glCopyPixels
  "glCopyPixels"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glCopyPixels"))
      (paramdef "GLint " (parameter "x"))
      (paramdef "GLint " (parameter "y"))
      (paramdef "GLsizei " (parameter "width"))
      (paramdef "GLsizei " (parameter "height"))
      (paramdef "GLenum " (parameter "type"))))
  '(*fragment*
     (heading "copy pixels in the frame buffer")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "x")))
                   (itemx (var "y"))
                   (para "
Specify the window coordinates of the lower left corner
                    of the rectangular region of pixels to be copied. "))
            (entry (% (heading (var "width")))
                   (itemx (var "height"))
                   (para "
Specify the dimensions of the rectangular region of pixels to be copied.
                    Both must be nonnegative. "))
            (entry (% (heading (var "type")))
                   (para "
Specifies whether color values,
                    depth values,
                    or stencil values are to be copied.
                    Symbolic constants "
                         (code "GL_COLOR")
                         ", "
                         (code "GL_DEPTH")
                         ",
                    and "
                         (code "GL_STENCIL")
                         " are accepted. ")))
     (heading "Description")
     (para (code "glCopyPixels")
           " copies a screen-aligned rectangle of pixels
            from the specified frame buffer location to a region relative to the
            current raster position.
            Its operation is well defined only if the entire pixel source region
            is within the exposed portion of the window.
            Results of copies from outside the window,
            or from regions of the window that are not exposed,
            are hardware dependent and undefined. ")
     (para (var "x")
           " and "
           (var "y")
           " specify the window coordinates of
            the lower left corner of the rectangular region to be copied. "
           (var "width")
           " and "
           (var "height")
           " specify the dimensions of the
            rectangular region to be copied.
            Both "
           (var "width")
           " and "
           (var "height")
           " must not be negative. ")
     (para "
Several parameters control the processing of the pixel data
            while it is being copied.
            These parameters are set with three commands: "
           (code "glPixelTransfer")
           ", "
           (code "glPixelMap")
           ", and "
           (code "glPixelZoom")
           ".
            This reference page describes the effects on "
           (code "glCopyPixels")
           " of most,
            but not all, of the parameters specified by these three commands. ")
     (para (code "glCopyPixels")
           " copies values from each pixel with the lower left-hand corner at "
           (math "("
                 (var "x")
                 "+"
                 (var "i")
                 ","
                 (var "y")
                 "+"
                 (var "j")
                 ")")
           "
for "
           (math "0" "<=" (var "i") "<" (var "width"))
           "
and "
           (math "0" "<=" (var "j") "<" (var "height"))
           ".
            This pixel is said to be the "
           (math (var "i"))
           "th
            pixel in the "
           (math (var "j"))
           "th
            row.
            Pixels are copied in row order from the lowest to the highest row,
            left to right in each row. ")
     (para (var "type")
           " specifies whether color, depth, or stencil data is to be copied.
            The details of the transfer for each data type are as follows: ")
     (table (% (formatter (asis)))
            (entry (% (heading (code "GL_COLOR")))
                   (para "
Indices or RGBA colors are read from the buffer currently specified as the
                        read source buffer (see "
                         (code "glReadBuffer")
                         ").
                        If the GL is in color index mode,
                        each index that is read from this buffer is converted
                        to a fixed-point format with an unspecified
                        number of bits to the right of the binary point.
                        Each index is then shifted left by "
                         (code "GL_INDEX_SHIFT")
                         " bits,
                        and added to "
                         (code "GL_INDEX_OFFSET")
                         ".
                        If "
                         (code "GL_INDEX_SHIFT")
                         " is negative,
                        the shift is to the right.
                        In either case, zero bits fill otherwise unspecified bit locations in the
                        result.
                        If "
                         (code "GL_MAP_COLOR")
                         " is true,
                        the index is replaced with the value that it references in lookup table "
                         (code "GL_PIXEL_MAP_I_TO_I")
                         ".
                        Whether the lookup replacement of the index is done or not,
                        the integer part of the index is then ANDed with "
                         (math "2" "^" (var "b") "-" "1")
                         ",
                        where "
                         (math (var "b"))
                         "
is the number of bits in a color index buffer. ")
                   (para "
If the GL is in RGBA mode,
                        the red, green, blue, and alpha components of each pixel that is read
                        are converted to an internal floating-point format with unspecified
                        precision.
                        The conversion maps the largest representable component value to 1.0,
                        and component value 0 to 0.0.
                        The resulting floating-point color values are then multiplied
                        by "
                         (code "GL_c_SCALE")
                         " and added to "
                         (code "GL_c_BIAS")
                         ",
                        where "
                         (var "c")
                         " is RED, GREEN, BLUE, and ALPHA
                        for the respective color components.
                        The results are clamped to the range [0,1].
                        If "
                         (code "GL_MAP_COLOR")
                         " is true,
                        each color component is scaled by the size of lookup table "
                         (code "GL_PIXEL_MAP_c_TO_c")
                         ",
                        then replaced by the value that it references in that table. "
                         (var "c")
                         " is R, G, B, or A. ")
                   (para "
If the "
                         (code "ARB_imaging")
                         " extension is supported, the color values may
                        be
                        additionally processed by color-table lookups, color-matrix
                        transformations, and convolution filters. ")
                   (para "
The GL then converts the resulting indices or RGBA colors to fragments
                        by attaching the current raster position "
                         (var "z")
                         " coordinate and
                        texture coordinates to each pixel,
                        then assigning window coordinates "
                         (math "("
                               (var "x")
                               "_"
                               (var "r")
                               "+"
                               (var "i")
                               ","
                               (var "y")
                               "_"
                               (var "r")
                               "+"
                               (var "j")
                               ")")
                         ",
                        where "
                         (math "("
                               (var "x")
                               "_"
                               (var "r")
                               ","
                               (var "y")
                               "_"
                               (var "r")
                               ")")
                         "
is the current raster position,
                        and the pixel was the "
                         (math (var "i"))
                         "th
                        pixel in the "
                         (math (var "j"))
                         "th
                        row.
                        These pixel fragments are then treated just like the fragments generated by
                        rasterizing points, lines, or polygons.
                        Texture mapping,
                        fog,
                        and all the fragment operations are applied before the fragments are written
                        to the frame buffer. "))
            (entry (% (heading (code "GL_DEPTH")))
                   (para "
Depth values are read from the depth buffer and
                        converted directly to an internal floating-point format
                        with unspecified precision.
                        The resulting floating-point depth value is then multiplied
                        by "
                         (code "GL_DEPTH_SCALE")
                         " and added to "
                         (code "GL_DEPTH_BIAS")
                         ".
                        The result is clamped to the range [0,1]. ")
                   (para "
The GL then converts the resulting depth components to fragments
                        by attaching the current raster position color or color index and
                        texture coordinates to each pixel,
                        then assigning window coordinates "
                         (math "("
                               (var "x")
                               "_"
                               (var "r")
                               "+"
                               (var "i")
                               ","
                               (var "y")
                               "_"
                               (var "r")
                               "+"
                               (var "j")
                               ")")
                         ",
                        where "
                         (math "("
                               (var "x")
                               "_"
                               (var "r")
                               ","
                               (var "y")
                               "_"
                               (var "r")
                               ")")
                         "
is the current raster position,
                        and the pixel was the "
                         (math (var "i"))
                         "th
                        pixel in the "
                         (math (var "j"))
                         "th
                        row.
                        These pixel fragments are then treated just like the fragments generated by
                        rasterizing points, lines, or polygons.
                        Texture mapping,
                        fog,
                        and all the fragment operations are applied before the fragments are written
                        to the frame buffer. "))
            (entry (% (heading (code "GL_STENCIL")))
                   (para "
Stencil indices are read from the stencil buffer and
                        converted to an internal fixed-point format
                        with an unspecified number of bits to the right of the binary point.
                        Each fixed-point index is then shifted left by "
                         (code "GL_INDEX_SHIFT")
                         " bits,
                        and added to "
                         (code "GL_INDEX_OFFSET")
                         ".
                        If "
                         (code "GL_INDEX_SHIFT")
                         " is negative,
                        the shift is to the right.
                        In either case, zero bits fill otherwise unspecified bit locations in the
                        result.
                        If "
                         (code "GL_MAP_STENCIL")
                         " is true,
                        the index is replaced with the value that it references in lookup table "
                         (code "GL_PIXEL_MAP_S_TO_S")
                         ".
                        Whether the lookup replacement of the index is done or not,
                        the integer part of the index is then ANDed with "
                         (math "2" "^" (var "b") "-" "1")
                         ",
                        where "
                         (math (var "b"))
                         "
is the number of bits in the stencil buffer.
                        The resulting stencil indices are then written to the stencil buffer
                        such that the index read from the "
                         (math (var "i"))
                         "th
                        location of the "
                         (math (var "j"))
                         "th
                        row
                        is written to location "
                         (math "("
                               (var "x")
                               "_"
                               (var "r")
                               "+"
                               (var "i")
                               ","
                               (var "y")
                               "_"
                               (var "r")
                               "+"
                               (var "j")
                               ")")
                         ",
                        where "
                         (math "("
                               (var "x")
                               "_"
                               (var "r")
                               ","
                               (var "y")
                               "_"
                               (var "r")
                               ")")
                         "
is the current raster position.
                        Only the pixel ownership test,
                        the scissor test,
                        and the stencil writemask affect these write operations. ")))
     (para "
The rasterization described thus far assumes pixel zoom factors of 1.0.
            If "
           (code "glPixelZoom")
           " is used to change the "
           (math (var "x"))
           "
and "
           (math (var "y"))
           "
pixel zoom factors,
            pixels are converted to fragments as follows.
            If "
           (math "("
                 (var "x")
                 "_"
                 (var "r")
                 ","
                 (var "y")
                 "_"
                 (var "r")
                 ")")
           "
is the current raster position,
            and a given pixel is in the "
           (math (var "i"))
           "th
            location in the "
           (math (var "j"))
           "th
            row of the source
            pixel rectangle,
            then fragments are generated for pixels whose centers are in the rectangle
            with corners at ")
     (para (math "("
                 (var "x")
                 "_"
                 (var "r")
                 "+"
                 (var "zoom")
                 "_"
                 (var "x")
                 ","
                 "\u2062"
                 (var "i")
                 ","
                 (var "y")
                 "_"
                 (var "r")
                 "+"
                 (var "zoom")
                 "_"
                 (var "y")
                 ","
                 "\u2062"
                 (var "j")
                 ")"))
     (para "
and ")
     (para (math "("
                 (var "x")
                 "_"
                 (var "r")
                 "+"
                 (var "zoom")
                 "_"
                 (var "x")
                 ","
                 "\u2061"
                 "("
                 (var "i")
                 "+"
                 "1"
                 ","
                 ")"
                 ","
                 (var "y")
                 "_"
                 (var "r")
                 "+"
                 (var "zoom")
                 "_"
                 (var "y")
                 ","
                 "\u2061"
                 "("
                 (var "j")
                 "+"
                 "1"
                 ","
                 ")"
                 ")"))
     (para "
where "
           (math (var "zoom") "_" (var "x"))
           "
is the value of "
           (code "GL_ZOOM_X")
           " and "
           (math (var "zoom") "_" (var "y"))
           "
is the value of "
           (code "GL_ZOOM_Y")
           ". ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "type")
           " is not an accepted value. ")
     (para (code "GL_INVALID_VALUE")
           " is generated if either "
           (var "width")
           " or "
           (var "height")
           " is negative. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (var "type")
           " is "
           (code "GL_DEPTH")
           "
and there is no depth buffer. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (var "type")
           " is "
           (code "GL_STENCIL")
           "
and there is no stencil buffer. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glCopyPixels")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glCopyTexImage1D
  "glCopyTexImage1D"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glCopyTexImage1D"))
      (paramdef "GLenum " (parameter "target"))
      (paramdef "GLint " (parameter "level"))
      (paramdef "GLenum " (parameter "internalformat"))
      (paramdef "GLint " (parameter "x"))
      (paramdef "GLint " (parameter "y"))
      (paramdef "GLsizei " (parameter "width"))
      (paramdef "GLint " (parameter "border"))))
  '(*fragment*
     (heading "copy pixels into a 1D texture image")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "target")))
                   (para "
Specifies the target texture.
                    Must be "
                         (code "GL_TEXTURE_1D")
                         ". "))
            (entry (% (heading (var "level")))
                   (para "
Specifies the level-of-detail number.
                    Level 0 is the base image level.
                    Level "
                         (var "n")
                         " is the "
                         (var "n")
                         "th mipmap reduction image. "))
            (entry (% (heading (var "internalformat")))
                   (para "
Specifies the internal format of the texture.
                    Must be one of the following symbolic constants: "
                         (code "GL_ALPHA")
                         ", "
                         (code "GL_ALPHA4")
                         ", "
                         (code "GL_ALPHA8")
                         ", "
                         (code "GL_ALPHA12")
                         ", "
                         (code "GL_ALPHA16")
                         ", "
                         (code "GL_COMPRESSED_ALPHA")
                         ", "
                         (code "GL_COMPRESSED_LUMINANCE")
                         ", "
                         (code "GL_COMPRESSED_LUMINANCE_ALPHA")
                         ", "
                         (code "GL_COMPRESSED_INTENSITY")
                         ", "
                         (code "GL_COMPRESSED_RGB")
                         ", "
                         (code "GL_COMPRESSED_RGBA")
                         ", "
                         (code "GL_DEPTH_COMPONENT")
                         ", "
                         (code "GL_DEPTH_COMPONENT16")
                         ", "
                         (code "GL_DEPTH_COMPONENT24")
                         ", "
                         (code "GL_DEPTH_COMPONENT32")
                         ", "
                         (code "GL_LUMINANCE")
                         ", "
                         (code "GL_LUMINANCE4")
                         ", "
                         (code "GL_LUMINANCE8")
                         ", "
                         (code "GL_LUMINANCE12")
                         ", "
                         (code "GL_LUMINANCE16")
                         ", "
                         (code "GL_LUMINANCE_ALPHA")
                         ", "
                         (code "GL_LUMINANCE4_ALPHA4")
                         ", "
                         (code "GL_LUMINANCE6_ALPHA2")
                         ", "
                         (code "GL_LUMINANCE8_ALPHA8")
                         ", "
                         (code "GL_LUMINANCE12_ALPHA4")
                         ", "
                         (code "GL_LUMINANCE12_ALPHA12")
                         ", "
                         (code "GL_LUMINANCE16_ALPHA16")
                         ", "
                         (code "GL_INTENSITY")
                         ", "
                         (code "GL_INTENSITY4")
                         ", "
                         (code "GL_INTENSITY8")
                         ", "
                         (code "GL_INTENSITY12")
                         ", "
                         (code "GL_INTENSITY16")
                         ", "
                         (code "GL_RGB")
                         ", "
                         (code "GL_R3_G3_B2")
                         ", "
                         (code "GL_RGB4")
                         ", "
                         (code "GL_RGB5")
                         ", "
                         (code "GL_RGB8")
                         ", "
                         (code "GL_RGB10")
                         ", "
                         (code "GL_RGB12")
                         ", "
                         (code "GL_RGB16")
                         ", "
                         (code "GL_RGBA")
                         ", "
                         (code "GL_RGBA2")
                         ", "
                         (code "GL_RGBA4")
                         ", "
                         (code "GL_RGB5_A1")
                         ", "
                         (code "GL_RGBA8")
                         ", "
                         (code "GL_RGB10_A2")
                         ", "
                         (code "GL_RGBA12")
                         ", "
                         (code "GL_RGBA16")
                         ", "
                         (code "GL_SLUMINANCE")
                         ", "
                         (code "GL_SLUMINANCE8")
                         ", "
                         (code "GL_SLUMINANCE_ALPHA")
                         ", "
                         (code "GL_SLUMINANCE8_ALPHA8")
                         ", "
                         (code "GL_SRGB")
                         ", "
                         (code "GL_SRGB8")
                         ", "
                         (code "GL_SRGB_ALPHA")
                         ", or "
                         (code "GL_SRGB8_ALPHA8")
                         ". "))
            (entry (% (heading (var "x")))
                   (itemx (var "y"))
                   (para "
Specify the window coordinates of the left corner
                    of the row of pixels to be copied. "))
            (entry (% (heading (var "width")))
                   (para "
Specifies the width of the texture image.
                    Must be 0 or "
                         (math "2"
                               "^"
                               (var "n")
                               "+"
                               "2"
                               "\u2061"
                               "("
                               (var "border")
                               ","
                               ")")
                         "
for some integer "
                         (math (var "n"))
                         ".
                    The height of the texture image is 1. "))
            (entry (% (heading (var "border")))
                   (para "
Specifies the width of the border.
                    Must be either 0 or 1. ")))
     (heading "Description")
     (para (code "glCopyTexImage1D")
           " defines a one-dimensional texture image with pixels from the current "
           (code "GL_READ_BUFFER")
           ". ")
     (para "
The screen-aligned pixel row with left corner at "
           (math "(" (var "x") "," (var "y") ")")
           "
and with a length of "
           (math (var "width")
                 "+"
                 "2"
                 "\u2061"
                 "("
                 (var "border")
                 ","
                 ")")
           "
defines the texture array
            at the mipmap level specified by "
           (var "level")
           ". "
           (var "internalformat")
           " specifies the internal format of the texture array. ")
     (para "
The pixels in the row are processed exactly as if "
           (code "glCopyPixels")
           " had been called, but the process stops just before
            final conversion.
            At this point all pixel component values are clamped to the range "
           (math "[" "0" "," "1" "]")
           "
and then converted to the texture's internal format for storage in the texel
            array. ")
     (para "
Pixel ordering is such that lower "
           (math (var "x"))
           "
screen coordinates correspond to
            lower texture coordinates. ")
     (para "
If any of the pixels within the specified row of the current "
           (code "GL_READ_BUFFER")
           " are outside the window associated with the current
            rendering context, then the values obtained for those pixels are undefined. ")
     (para (code "glCopyTexImage1D")
           " defines a one-dimensional texture image with pixels from the current "
           (code "GL_READ_BUFFER")
           ". ")
     (para "
When "
           (var "internalformat")
           " is one of the sRGB  types, the GL does not automatically convert the source pixels to the sRGB color space.  In this case, the "
           (code "glPixelMap")
           " function can be used to accomplish the conversion. ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "target")
           " is not one of the allowable values. ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "level")
           " is less than 0. ")
     (para (code "GL_INVALID_VALUE")
           " may be generated if "
           (var "level")
           " is greater
            than "
           (math (var "log") "_" "2" "\u2062" (var "max"))
           ",
            where "
           (math (var "max"))
           "
is the returned value of "
           (code "GL_MAX_TEXTURE_SIZE")
           ". ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "internalformat")
           " is not an allowable value. ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "width")
           " is less than 0 or greater than
            2 + "
           (code "GL_MAX_TEXTURE_SIZE")
           ". ")
     (para (code "GL_INVALID_VALUE")
           " is generated if non-power-of-two textures are not supported and the "
           (var "width")
           " cannot be represented as "
           (math "2"
                 "^"
                 (var "n")
                 "+"
                 "2"
                 "\u2061"
                 "("
                 (var "border")
                 ","
                 ")")
           "
for some integer value of "
           (var "n")
           ". ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "border")
           " is not 0 or 1. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glCopyTexImage1D")
           " is executed between the execution of "
           (code "glBegin")
           " and the corresponding execution of "
           (code "glEnd")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (var "internalformat")
           " is "
           (code "GL_DEPTH_COMPONENT")
           ", "
           (code "GL_DEPTH_COMPONENT16")
           ", "
           (code "GL_DEPTH_COMPONENT24")
           ", or "
           (code "GL_DEPTH_COMPONENT32")
           " and there is no depth
            buffer. ")))

(define-gl-procedure
  glCopyTexImage2D
  "glCopyTexImage2D"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glCopyTexImage2D"))
      (paramdef "GLenum " (parameter "target"))
      (paramdef "GLint " (parameter "level"))
      (paramdef "GLenum " (parameter "internalformat"))
      (paramdef "GLint " (parameter "x"))
      (paramdef "GLint " (parameter "y"))
      (paramdef "GLsizei " (parameter "width"))
      (paramdef "GLsizei " (parameter "height"))
      (paramdef "GLint " (parameter "border"))))
  '(*fragment*
     (heading "copy pixels into a 2D texture image")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "target")))
                   (para "
Specifies the target texture.
                    Must be "
                         (code "GL_TEXTURE_2D")
                         ", "
                         (code "GL_TEXTURE_CUBE_MAP_POSITIVE_X")
                         ", "
                         (code "GL_TEXTURE_CUBE_MAP_NEGATIVE_X")
                         ", "
                         (code "GL_TEXTURE_CUBE_MAP_POSITIVE_Y")
                         ", "
                         (code "GL_TEXTURE_CUBE_MAP_NEGATIVE_Y")
                         ", "
                         (code "GL_TEXTURE_CUBE_MAP_POSITIVE_Z")
                         ", or "
                         (code "GL_TEXTURE_CUBE_MAP_NEGATIVE_Z")
                         ". "))
            (entry (% (heading (var "level")))
                   (para "
Specifies the level-of-detail number.
                    Level 0 is the base image level.
                    Level "
                         (var "n")
                         " is the "
                         (var "n")
                         "th mipmap reduction image. "))
            (entry (% (heading (var "internalformat")))
                   (para "
Specifies the internal format of the texture.
                    Must be one of the following symbolic constants: "
                         (code "GL_ALPHA")
                         ", "
                         (code "GL_ALPHA4")
                         ", "
                         (code "GL_ALPHA8")
                         ", "
                         (code "GL_ALPHA12")
                         ", "
                         (code "GL_ALPHA16")
                         ", "
                         (code "GL_COMPRESSED_ALPHA")
                         ", "
                         (code "GL_COMPRESSED_LUMINANCE")
                         ", "
                         (code "GL_COMPRESSED_LUMINANCE_ALPHA")
                         ", "
                         (code "GL_COMPRESSED_INTENSITY")
                         ", "
                         (code "GL_COMPRESSED_RGB")
                         ", "
                         (code "GL_COMPRESSED_RGBA")
                         ", "
                         (code "GL_DEPTH_COMPONENT")
                         ", "
                         (code "GL_DEPTH_COMPONENT16")
                         ", "
                         (code "GL_DEPTH_COMPONENT24")
                         ", "
                         (code "GL_DEPTH_COMPONENT32")
                         ", "
                         (code "GL_LUMINANCE")
                         ", "
                         (code "GL_LUMINANCE4")
                         ", "
                         (code "GL_LUMINANCE8")
                         ", "
                         (code "GL_LUMINANCE12")
                         ", "
                         (code "GL_LUMINANCE16")
                         ", "
                         (code "GL_LUMINANCE_ALPHA")
                         ", "
                         (code "GL_LUMINANCE4_ALPHA4")
                         ", "
                         (code "GL_LUMINANCE6_ALPHA2")
                         ", "
                         (code "GL_LUMINANCE8_ALPHA8")
                         ", "
                         (code "GL_LUMINANCE12_ALPHA4")
                         ", "
                         (code "GL_LUMINANCE12_ALPHA12")
                         ", "
                         (code "GL_LUMINANCE16_ALPHA16")
                         ", "
                         (code "GL_INTENSITY")
                         ", "
                         (code "GL_INTENSITY4")
                         ", "
                         (code "GL_INTENSITY8")
                         ", "
                         (code "GL_INTENSITY12")
                         ", "
                         (code "GL_INTENSITY16")
                         ", "
                         (code "GL_RGB")
                         ", "
                         (code "GL_R3_G3_B2")
                         ", "
                         (code "GL_RGB4")
                         ", "
                         (code "GL_RGB5")
                         ", "
                         (code "GL_RGB8")
                         ", "
                         (code "GL_RGB10")
                         ", "
                         (code "GL_RGB12")
                         ", "
                         (code "GL_RGB16")
                         ", "
                         (code "GL_RGBA")
                         ", "
                         (code "GL_RGBA2")
                         ", "
                         (code "GL_RGBA4")
                         ", "
                         (code "GL_RGB5_A1")
                         ", "
                         (code "GL_RGBA8")
                         ", "
                         (code "GL_RGB10_A2")
                         ", "
                         (code "GL_RGBA12")
                         ", "
                         (code "GL_RGBA16")
                         ", "
                         (code "GL_SLUMINANCE")
                         ", "
                         (code "GL_SLUMINANCE8")
                         ", "
                         (code "GL_SLUMINANCE_ALPHA")
                         ", "
                         (code "GL_SLUMINANCE8_ALPHA8")
                         ", "
                         (code "GL_SRGB")
                         ", "
                         (code "GL_SRGB8")
                         ", "
                         (code "GL_SRGB_ALPHA")
                         ", or "
                         (code "GL_SRGB8_ALPHA8")
                         ". "))
            (entry (% (heading (var "x")))
                   (itemx (var "y"))
                   (para "
Specify the window coordinates of the lower left corner
                    of the rectangular region of pixels to be copied. "))
            (entry (% (heading (var "width")))
                   (para "
Specifies the width of the texture image.
                    Must be 0 or "
                         (math "2"
                               "^"
                               (var "n")
                               "+"
                               "2"
                               "\u2061"
                               "("
                               (var "border")
                               ","
                               ")")
                         "
for some integer "
                         (math (var "n"))
                         ". "))
            (entry (% (heading (var "height")))
                   (para "
Specifies the height of the texture image.
                    Must be 0 or "
                         (math "2"
                               "^"
                               (var "m")
                               "+"
                               "2"
                               "\u2061"
                               "("
                               (var "border")
                               ","
                               ")")
                         "
for some integer "
                         (math (var "m"))
                         ". "))
            (entry (% (heading (var "border")))
                   (para "
Specifies the width of the border.
                    Must be either 0 or 1. ")))
     (heading "Description")
     (para (code "glCopyTexImage2D")
           " defines a two-dimensional texture image, or cube-map texture image
            with pixels from the current "
           (code "GL_READ_BUFFER")
           ". ")
     (para "
The screen-aligned pixel rectangle with lower left corner at ("
           (var "x")
           ", "
           (var "y")
           ") and with a width of "
           (math (var "width")
                 "+"
                 "2"
                 "\u2061"
                 "("
                 (var "border")
                 ","
                 ")")
           "
and a height of "
           (math (var "height")
                 "+"
                 "2"
                 "\u2061"
                 "("
                 (var "border")
                 ","
                 ")")
           "
defines the texture array
            at the mipmap level specified by "
           (var "level")
           ". "
           (var "internalformat")
           " specifies the internal format of the texture array. ")
     (para "
The pixels in the rectangle are processed exactly as if "
           (code "glCopyPixels")
           " had been called, but the process stops just before
            final conversion.
            At this point all pixel component values are clamped to the range "
           (math "[" "0" "," "1" "]")
           "
and then converted to the texture's internal format for storage in the texel
            array. ")
     (para "
Pixel ordering is such that lower "
           (math (var "x"))
           "
and "
           (math (var "y"))
           "
screen coordinates correspond to
            lower "
           (math (var "s"))
           "
and "
           (math (var "t"))
           "
texture coordinates. ")
     (para "
If any of the pixels within the specified rectangle of the current "
           (code "GL_READ_BUFFER")
           " are outside the window associated with the current
            rendering context, then the values obtained for those pixels are undefined. ")
     (para "
When "
           (var "internalformat")
           " is one of the sRGB  types, the GL does not automatically convert the source pixels to the sRGB color space.  In this case, the "
           (code "glPixelMap")
           " function can be used to accomplish the conversion. ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "target")
           " is not "
           (code "GL_TEXTURE_2D")
           ", "
           (code "GL_TEXTURE_CUBE_MAP_POSITIVE_X")
           ", "
           (code "GL_TEXTURE_CUBE_MAP_NEGATIVE_X")
           ", "
           (code "GL_TEXTURE_CUBE_MAP_POSITIVE_Y")
           ", "
           (code "GL_TEXTURE_CUBE_MAP_NEGATIVE_Y")
           ", "
           (code "GL_TEXTURE_CUBE_MAP_POSITIVE_Z")
           ", or "
           (code "GL_TEXTURE_CUBE_MAP_NEGATIVE_Z")
           ". ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "level")
           " is less than 0. ")
     (para (code "GL_INVALID_VALUE")
           " may be generated if "
           (var "level")
           " is greater
            than "
           (math (var "log") "_" "2" "\u2062" (var "max"))
           ",
            where "
           (math (var "max"))
           "
is the returned value of "
           (code "GL_MAX_TEXTURE_SIZE")
           ". ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "width")
           " is less than 0
            or greater than
            2 + "
           (code "GL_MAX_TEXTURE_SIZE")
           ". ")
     (para (code "GL_INVALID_VALUE")
           " is generated if non-power-of-two textures are not supported and the "
           (var "width")
           " or "
           (var "depth")
           " cannot be represented as "
           (math "2"
                 "^"
                 (var "k")
                 "+"
                 "2"
                 "\u2061"
                 "("
                 (var "border")
                 ","
                 ")")
           "
for some integer "
           (math (var "k"))
           ". ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "border")
           " is not 0 or 1. ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "internalformat")
           " is not an
            accepted format. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glCopyTexImage2D")
           " is executed
            between the execution of "
           (code "glBegin")
           " and the corresponding
            execution of "
           (code "glEnd")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (var "internalformat")
           " is "
           (code "GL_DEPTH_COMPONENT")
           ", "
           (code "GL_DEPTH_COMPONENT16")
           ", "
           (code "GL_DEPTH_COMPONENT24")
           ", or "
           (code "GL_DEPTH_COMPONENT32")
           " and there is no depth
            buffer. ")))

(define-gl-procedure
  glCopyTexSubImage1D
  "glCopyTexSubImage1D"
  (funcsynopsis
    (funcprototype
      (funcdef
        "void "
        (function "glCopyTexSubImage1D"))
      (paramdef "GLenum " (parameter "target"))
      (paramdef "GLint " (parameter "level"))
      (paramdef "GLint " (parameter "xoffset"))
      (paramdef "GLint " (parameter "x"))
      (paramdef "GLint " (parameter "y"))
      (paramdef "GLsizei " (parameter "width"))))
  '(*fragment*
     (heading
       "copy a one-dimensional texture subimage")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "target")))
                   (para "
Specifies the target texture.
                    Must be "
                         (code "GL_TEXTURE_1D")
                         ". "))
            (entry (% (heading (var "level")))
                   (para "
Specifies the level-of-detail number.
                    Level 0 is the base image level.
                    Level "
                         (var "n")
                         " is the "
                         (var "n")
                         "th mipmap reduction image. "))
            (entry (% (heading (var "xoffset")))
                   (para "
Specifies the texel offset within the texture array. "))
            (entry (% (heading (var "x")))
                   (itemx (var "y"))
                   (para "
Specify the window coordinates of the left corner
                    of the row of pixels to be copied. "))
            (entry (% (heading (var "width")))
                   (para "
Specifies the width of the texture subimage. ")))
     (heading "Description")
     (para (code "glCopyTexSubImage1D")
           " replaces a portion of a one-dimensional
            texture image with pixels from the current "
           (code "GL_READ_BUFFER")
           " (rather
            than from main memory, as is the case for "
           (code "glTexSubImage1D")
           "). ")
     (para "
The screen-aligned pixel row with left corner at ("
           (var "x")
           ",\\ "
           (var "y")
           "), and with
            length "
           (var "width")
           " replaces the portion of the
            texture array with x indices "
           (var "xoffset")
           " through "
           (math (var "xoffset") "+" (var "width") "-" "1")
           ",
            inclusive. The destination in the texture array may not
            include any texels outside the texture array as it was
            originally specified. ")
     (para "
The pixels in the row are processed exactly as if "
           (code "glCopyPixels")
           " had been called, but the process stops just before
            final conversion.
            At this point, all pixel component values are clamped to the range "
           (math "[" "0" "," "1" "]")
           "
and then converted to the texture's internal format for storage in the texel
            array. ")
     (para "
It is not an error to specify a subtexture with zero width, but
            such a specification has no effect.
            If any of the pixels within the specified row of the current "
           (code "GL_READ_BUFFER")
           " are outside the read window associated with the current
            rendering context, then the values obtained for those pixels are undefined. ")
     (para "
No change is made to the "
           (var "internalformat")
           ", "
           (var "width")
           ",
            or "
           (var "border")
           " parameters of the specified texture
            array or to texel values outside the specified subregion. ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if /"
           (var "target")
           " is not "
           (code "GL_TEXTURE_1D")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if the texture array has not
            been defined by a previous "
           (code "glTexImage1D")
           " or "
           (code "glCopyTexImage1D")
           " operation. ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "level")
           " is less than 0. ")
     (para (code "GL_INVALID_VALUE")
           " may be generated if "
           (math (var "level")
                 ">"
                 (var "log")
                 "_"
                 "2"
                 "\u2061"
                 "("
                 (var "max")
                 ","
                 ")")
           ",
            where "
           (var "max")
           " is the returned value of "
           (code "GL_MAX_TEXTURE_SIZE")
           ". ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (math (var "xoffset") "<" "-" (var "b"))
           ",
            or "
           (math "("
                 (var "xoffset")
                 "+"
                 (var "width")
                 ","
                 ")"
                 ">"
                 "("
                 (var "w")
                 "-"
                 (var "b")
                 ","
                 ")")
           ",
            where "
           (math (var "w"))
           "
is the "
           (code "GL_TEXTURE_WIDTH")
           " and "
           (math (var "b"))
           "
is the "
           (code "GL_TEXTURE_BORDER")
           "
of the texture image being modified.
            Note that "
           (math (var "w"))
           "
includes twice the border width. ")
     (para)))

(define-gl-procedure
  glCopyTexSubImage2D
  "glCopyTexSubImage2D"
  (funcsynopsis
    (funcprototype
      (funcdef
        "void "
        (function "glCopyTexSubImage2D"))
      (paramdef "GLenum " (parameter "target"))
      (paramdef "GLint " (parameter "level"))
      (paramdef "GLint " (parameter "xoffset"))
      (paramdef "GLint " (parameter "yoffset"))
      (paramdef "GLint " (parameter "x"))
      (paramdef "GLint " (parameter "y"))
      (paramdef "GLsizei " (parameter "width"))
      (paramdef "GLsizei " (parameter "height"))))
  '(*fragment*
     (heading
       "copy a two-dimensional texture subimage")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "target")))
                   (para "
Specifies the target texture.
                    Must be "
                         (code "GL_TEXTURE_2D")
                         ", "
                         (code "GL_TEXTURE_CUBE_MAP_POSITIVE_X")
                         ", "
                         (code "GL_TEXTURE_CUBE_MAP_NEGATIVE_X")
                         ", "
                         (code "GL_TEXTURE_CUBE_MAP_POSITIVE_Y")
                         ", "
                         (code "GL_TEXTURE_CUBE_MAP_NEGATIVE_Y")
                         ", "
                         (code "GL_TEXTURE_CUBE_MAP_POSITIVE_Z")
                         ", or "
                         (code "GL_TEXTURE_CUBE_MAP_NEGATIVE_Z")
                         ". "))
            (entry (% (heading (var "level")))
                   (para "
Specifies the level-of-detail number.
                    Level 0 is the base image level.
                    Level "
                         (var "n")
                         " is the "
                         (var "n")
                         "th mipmap reduction image. "))
            (entry (% (heading (var "xoffset")))
                   (para "
Specifies a texel offset in the x direction within the texture array. "))
            (entry (% (heading (var "yoffset")))
                   (para "
Specifies a texel offset in the y direction within the texture array. "))
            (entry (% (heading (var "x")))
                   (itemx (var "y"))
                   (para "
Specify the window coordinates of the lower left corner
                    of the rectangular region of pixels to be copied. "))
            (entry (% (heading (var "width")))
                   (para "
Specifies the width of the texture subimage. "))
            (entry (% (heading (var "height")))
                   (para "
Specifies the height of the texture subimage. ")))
     (heading "Description")
     (para (code "glCopyTexSubImage2D")
           " replaces a rectangular portion of a two-dimensional texture image or
            cube-map texture image with pixels from the current "
           (code "GL_READ_BUFFER")
           "
(rather than from main memory, as is the case for "
           (code "glTexSubImage2D")
           "). ")
     (para "
The screen-aligned pixel rectangle with lower left corner at "
           (math "(" (var "x") "," (var "y") ")")
           "
and with
            width "
           (var "width")
           " and height "
           (var "height")
           " replaces the portion of the
            texture array with x indices "
           (var "xoffset")
           " through "
           (math (var "xoffset") "+" (var "width") "-" "1")
           ",
            inclusive, and y indices "
           (var "yoffset")
           " through "
           (math (var "yoffset") "+" (var "height") "-" "1")
           ",
            inclusive, at the mipmap level specified by "
           (var "level")
           ". ")
     (para "
The pixels in the rectangle are processed exactly as if "
           (code "glCopyPixels")
           " had been called, but the process stops just before
            final conversion.
            At this point, all pixel component values are clamped to the range "
           (math "[" "0" "," "1" "]")
           "
and then converted to the texture's internal format for storage in the texel
            array. ")
     (para "
The destination rectangle in the texture array may not include any texels
            outside the texture array as it was originally specified.
            It is not an error to specify a subtexture with zero width or height, but
            such a specification has no effect. ")
     (para "
If any of the pixels within the specified rectangle of the current "
           (code "GL_READ_BUFFER")
           " are outside the read window associated with the current
            rendering context, then the values obtained for those pixels are undefined. ")
     (para "
No change is made to the "
           (var "internalformat")
           ", "
           (var "width")
           ", "
           (var "height")
           ", or "
           (var "border")
           " parameters of the specified texture
            array or to texel values outside the specified subregion. ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "target")
           " is not "
           (code "GL_TEXTURE_2D")
           ", "
           (code "GL_TEXTURE_CUBE_MAP_POSITIVE_X")
           ", "
           (code "GL_TEXTURE_CUBE_MAP_NEGATIVE_X")
           ", "
           (code "GL_TEXTURE_CUBE_MAP_POSITIVE_Y")
           ", "
           (code "GL_TEXTURE_CUBE_MAP_NEGATIVE_Y")
           ", "
           (code "GL_TEXTURE_CUBE_MAP_POSITIVE_Z")
           ", or "
           (code "GL_TEXTURE_CUBE_MAP_NEGATIVE_Z")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if the texture array has not been
            defined by a previous "
           (code "glTexImage2D")
           " or "
           (code "glCopyTexImage2D")
           " operation. ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "level")
           " is less than 0. ")
     (para (code "GL_INVALID_VALUE")
           " may be generated if "
           (math (var "level")
                 ">"
                 (var "log")
                 "_"
                 "2"
                 "\u2061"
                 "("
                 (var "max")
                 ","
                 ")")
           ",
            where "
           (math (var "max"))
           "
is the returned value of "
           (code "GL_MAX_TEXTURE_SIZE")
           ". ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (math (var "xoffset") "<" "-" (var "b"))
           ", "
           (math "("
                 (var "xoffset")
                 "+"
                 (var "width")
                 ","
                 ")"
                 ">"
                 "("
                 (var "w")
                 "-"
                 (var "b")
                 ","
                 ")")
           ", "
           (math (var "yoffset") "<" "-" (var "b"))
           ",
            or "
           (math "("
                 (var "yoffset")
                 "+"
                 (var "height")
                 ","
                 ")"
                 ">"
                 "("
                 (var "h")
                 "-"
                 (var "b")
                 ","
                 ")")
           ",
            where "
           (math (var "w"))
           "
is the "
           (code "GL_TEXTURE_WIDTH")
           ", "
           (math (var "h"))
           "
is the "
           (code "GL_TEXTURE_HEIGHT")
           ",
            and "
           (math (var "b"))
           "
is the "
           (code "GL_TEXTURE_BORDER")
           "
of the texture image being modified.
            Note that "
           (math (var "w"))
           "
and "
           (math (var "h"))
           "
include twice the border width. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glCopyTexSubImage2D")
           " is executed
            between the execution of "
           (code "glBegin")
           " and the corresponding
            execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glCopyTexSubImage3D
  "glCopyTexSubImage3D"
  (funcsynopsis
    (funcprototype
      (funcdef
        "void "
        (function "glCopyTexSubImage3D"))
      (paramdef "GLenum " (parameter "target"))
      (paramdef "GLint " (parameter "level"))
      (paramdef "GLint " (parameter "xoffset"))
      (paramdef "GLint " (parameter "yoffset"))
      (paramdef "GLint " (parameter "zoffset"))
      (paramdef "GLint " (parameter "x"))
      (paramdef "GLint " (parameter "y"))
      (paramdef "GLsizei " (parameter "width"))
      (paramdef "GLsizei " (parameter "height"))))
  '(*fragment*
     (heading
       "copy a three-dimensional texture subimage")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "target")))
                   (para "
Specifies the target texture.
                    Must be "
                         (code "GL_TEXTURE_3D")))
            (entry (% (heading (var "level")))
                   (para "
Specifies the level-of-detail number.
                    Level 0 is the base image level.
                    Level "
                         (var "n")
                         " is the "
                         (var "n")
                         "th mipmap reduction image. "))
            (entry (% (heading (var "xoffset")))
                   (para "
Specifies a texel offset in the x direction within the texture array. "))
            (entry (% (heading (var "yoffset")))
                   (para "
Specifies a texel offset in the y direction within the texture array. "))
            (entry (% (heading (var "zoffset")))
                   (para "
Specifies a texel offset in the z direction within the texture array. "))
            (entry (% (heading (var "x")))
                   (itemx (var "y"))
                   (para "
Specify the window coordinates of the lower left corner
                    of the rectangular region of pixels to be copied. "))
            (entry (% (heading (var "width")))
                   (para "
Specifies the width of the texture subimage. "))
            (entry (% (heading (var "height")))
                   (para "
Specifies the height of the texture subimage. ")))
     (heading "Description")
     (para (code "glCopyTexSubImage3D")
           " replaces a rectangular portion of a three-dimensional
            texture image with pixels from the current "
           (code "GL_READ_BUFFER")
           " (rather
            than from main memory, as is the case for "
           (code "glTexSubImage3D")
           "). ")
     (para "
The screen-aligned pixel rectangle with lower left corner at
            ("
           (var "x")
           ",\\ "
           (var "y")
           ") and with
            width "
           (var "width")
           " and height "
           (var "height")
           " replaces the portion of the
            texture array with x indices "
           (var "xoffset")
           " through "
           (math (var "xoffset") "+" (var "width") "-" "1")
           ",
            inclusive, and y indices "
           (var "yoffset")
           " through "
           (math (var "yoffset") "+" (var "height") "-" "1")
           ",
            inclusive, at z index "
           (var "zoffset")
           " and at the mipmap level specified by "
           (var "level")
           ". ")
     (para "
The pixels in the rectangle are processed exactly as if "
           (code "glCopyPixels")
           " had been called, but the process stops just before
            final conversion.
            At this point, all pixel component values are clamped to the range "
           (math "[" "0" "," "1" "]")
           "
and then converted to the texture's internal format for storage in the texel
            array. ")
     (para "
The destination rectangle in the texture array may not include any texels
            outside the texture array as it was originally specified.
            It is not an error to specify a subtexture with zero width or height, but
            such a specification has no effect. ")
     (para "
If any of the pixels within the specified rectangle of the current "
           (code "GL_READ_BUFFER")
           " are outside the read window associated with the current
            rendering context, then the values obtained for those pixels are undefined. ")
     (para "
No change is made to the "
           (var "internalformat")
           ", "
           (var "width")
           ", "
           (var "height")
           ", "
           (var "depth")
           ", or "
           (var "border")
           " parameters of the specified texture
            array or to texel values outside the specified subregion. ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if /"
           (var "target")
           " is not "
           (code "GL_TEXTURE_3D")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if the texture array has not
            been defined by a previous "
           (code "glTexImage3D")
           " operation. ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "level")
           " is less than 0. ")
     (para (code "GL_INVALID_VALUE")
           " may be generated if "
           (math (var "level")
                 ">"
                 (var "log")
                 "_"
                 "2"
                 "\u2061"
                 "("
                 (var "max")
                 ","
                 ")")
           ",
            where "
           (math (var "max"))
           "
is the returned value of "
           (code "GL_MAX_3D_TEXTURE_SIZE")
           ". ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (math (var "xoffset") "<" "-" (var "b"))
           ", "
           (math "("
                 (var "xoffset")
                 "+"
                 (var "width")
                 ","
                 ")"
                 ">"
                 "("
                 (var "w")
                 "-"
                 (var "b")
                 ","
                 ")")
           ", "
           (math (var "yoffset") "<" "-" (var "b"))
           ", "
           (math "("
                 (var "yoffset")
                 "+"
                 (var "height")
                 ","
                 ")"
                 ">"
                 "("
                 (var "h")
                 "-"
                 (var "b")
                 ","
                 ")")
           ", "
           (math (var "zoffset") "<" "-" (var "b"))
           ",
            or "
           (math "("
                 (var "zoffset")
                 "+"
                 "1"
                 ","
                 ")"
                 ">"
                 "("
                 (var "d")
                 "-"
                 (var "b")
                 ","
                 ")")
           ",
            where "
           (math (var "w"))
           "
is the "
           (code "GL_TEXTURE_WIDTH")
           ", "
           (math (var "h"))
           "
is the "
           (code "GL_TEXTURE_HEIGHT")
           ", "
           (math (var "d"))
           "
is the "
           (code "GL_TEXTURE_DEPTH")
           ",
            and "
           (math (var "b"))
           "
is the "
           (code "GL_TEXTURE_BORDER")
           "
of the texture image being modified.
            Note that "
           (math (var "w"))
           ", "
           (math (var "h"))
           ",
            and "
           (math (var "d"))
           "
include twice the border width. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glCopyTexSubImage3D")
           " is executed
            between the execution of "
           (code "glBegin")
           " and the corresponding
            execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glCreateProgram
  "glCreateProgram"
  (funcsynopsis
    (funcprototype
      (funcdef "GLuint " (function "glCreateProgram"))
      (paramdef (parameter "void"))))
  '(*fragment*
     (heading "Creates a program object")
     (heading "Description")
     (para (code "glCreateProgram")
           " creates an empty
\tprogram object and returns a non-zero value by which it can be
\treferenced. A program object is an object to which shader
\tobjects can be attached. This provides a mechanism to specify
\tthe shader objects that will be linked to create a program. It
\talso provides a means for checking the compatibility of the
\tshaders that will be used to create a program (for instance,
\tchecking the compatibility between a vertex shader and a
\tfragment shader). When no longer needed as part of a program
\tobject, shader objects can be detached.")
     (para "One or more executables are created in a program object by
\tsuccessfully attaching shader objects to it with\t"
           (code "glAttachShader")
           ",
\tsuccessfully compiling the shader objects with\t"
           (code "glCompileShader")
           ",
\tand successfully linking the program object with\t"
           (code "glLinkProgram")
           ".
\tThese executables are made part of current state when\t"
           (code "glUseProgram")
           "
is called. Program objects can be deleted by calling\t"
           (code "glDeleteProgram")
           ".
\tThe memory associated with the program object will be deleted
\twhen it is no longer part of current rendering state for any
\tcontext.")
     (heading "Errors")
     (para "This function returns 0 if an error occurs creating the program object.")
     (para (code "GL_INVALID_OPERATION")
           " is generated if\t"
           (code "glCreateProgram")
           " is executed between the
\texecution of\t"
           (code "glBegin")
           "
and the corresponding execution of\t"
           (code "glEnd")
           ".")))

(define-gl-procedure
  glCreateShader
  "glCreateShader"
  (funcsynopsis
    (funcprototype
      (funcdef "GLuint " (function "glCreateShader"))
      (paramdef "GLenum " (parameter "shaderType"))))
  '(*fragment*
     (heading "Creates a shader object")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "shaderType")))
                   (para "Specifies the type of shader to be created.
\t\t    Must be either "
                         (code "GL_VERTEX_SHADER")
                         "
or "
                         (code "GL_FRAGMENT_SHADER")
                         ".")))
     (heading "Description")
     (para (code "glCreateShader")
           " creates an empty
\tshader object and returns a non-zero value by which it can be
\treferenced. A shader object is used to maintain the source code
\tstrings that define a shader. "
           (var "shaderType")
           "
indicates the type of shader to be created. Two types of shaders
\tare supported. A shader of type\t"
           (code "GL_VERTEX_SHADER")
           " is a shader that is
\tintended to run on the programmable vertex processor and replace
\tthe fixed functionality vertex processing in OpenGL. A shader of
\ttype "
           (code "GL_FRAGMENT_SHADER")
           " is a shader that is
\tintended to run on the programmable fragment processor and
\treplace the fixed functionality fragment processing in
\tOpenGL.")
     (para "When created, a shader object's\t"
           (code "GL_SHADER_TYPE")
           " parameter is set to either\t"
           (code "GL_VERTEX_SHADER")
           " or\t"
           (code "GL_FRAGMENT_SHADER")
           ", depending on the value
\tof "
           (var "shaderType")
           ".")
     (heading "Errors")
     (para "This function returns 0 if an error occurs creating the
\tshader object.")
     (para (code "GL_INVALID_ENUM")
           " is generated if\t"
           (var "shaderType")
           " is not an accepted value.")
     (para (code "GL_INVALID_OPERATION")
           " is generated if\t"
           (code "glCreateShader")
           " is executed between the
\texecution of\t"
           (code "glBegin")
           "
and the corresponding execution of\t"
           (code "glEnd")
           ".")))

(define-gl-procedure
  glCullFace
  "glCullFace"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glCullFace"))
      (paramdef "GLenum " (parameter "mode"))))
  '(*fragment*
     (heading
       "specify whether front- or back-facing facets can be culled")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "mode")))
                   (para "
Specifies whether front- or back-facing facets are candidates for culling.
                    Symbolic constants "
                         (code "GL_FRONT")
                         ", "
                         (code "GL_BACK")
                         ", and "
                         (code "GL_FRONT_AND_BACK")
                         " are accepted.
                    The initial value is "
                         (code "GL_BACK")
                         ". ")))
     (heading "Description")
     (para (code "glCullFace")
           " specifies whether front- or back-facing facets are culled
            (as specified by "
           (var "mode")
           ") when facet culling is enabled. Facet
            culling is initially disabled.
            To enable and disable facet culling, call the "
           (code "glEnable")
           " and "
           (code "glDisable")
           " commands
            with the argument "
           (code "GL_CULL_FACE")
           ".
            Facets include triangles,
            quadrilaterals,
            polygons, and
            rectangles. ")
     (para (code "glFrontFace")
           " specifies which of the clockwise and counterclockwise facets
            are front-facing and back-facing.
            See "
           (code "glFrontFace")
           ". ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "mode")
           " is not an accepted value. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glCullFace")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glDeleteBuffers
  "glDeleteBuffers"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glDeleteBuffers"))
      (paramdef "GLsizei " (parameter "n"))
      (paramdef
        "const GLuint * "
        (parameter "buffers"))))
  '(*fragment*
     (heading "delete named buffer objects")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "n")))
                   (para "
Specifies the number of buffer objects to be deleted. "))
            (entry (% (heading (var "buffers")))
                   (para "
Specifies an array of buffer objects to be deleted. ")))
     (heading "Description")
     (para (code "glDeleteBuffers")
           " deletes "
           (var "n")
           " buffer objects named by the elements of the array "
           (var "buffers")
           ".
            After a buffer object is deleted, it has no contents,
            and its name is free for reuse (for example by "
           (code "glGenBuffers")
           ").
            If a buffer object that is currently bound is deleted, the binding reverts
            to 0 (the absence of any buffer object, which reverts to client memory usage). ")
     (para (code "glDeleteBuffers")
           " silently ignores 0's and names that do not correspond to
            existing buffer objects. ")
     (heading "Errors")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "n")
           " is negative. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glDeleteBuffers")
           " is executed
            between the execution of "
           (code "glBegin")
           " and the corresponding
            execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glDeleteLists
  "glDeleteLists"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glDeleteLists"))
      (paramdef "GLuint " (parameter "list"))
      (paramdef "GLsizei " (parameter "range"))))
  '(*fragment*
     (heading
       "delete a contiguous group of display lists")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "list")))
                   (para "
Specifies the integer name of the first display list to delete. "))
            (entry (% (heading (var "range")))
                   (para "
Specifies the number of display lists to delete. ")))
     (heading "Description")
     (para (code "glDeleteLists")
           " causes a contiguous group of display lists to be deleted. "
           (var "list")
           " is the name of the first display list to be deleted,
            and "
           (var "range")
           " is the number of display lists to delete.
            All display lists "
           (math (var "d"))
           "
with "
           (math (var "list")
                 "<="
                 (var "d")
                 "<="
                 (var "list")
                 "+"
                 (var "range")
                 "-"
                 "1")
           "
are deleted. ")
     (para "
All storage locations allocated to the specified display lists are freed,
            and the names are available for reuse at a later time.
            Names within the range that do not have an associated display list are ignored.
            If "
           (var "range")
           " is 0, nothing happens. ")
     (heading "Errors")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "range")
           " is negative. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glDeleteLists")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glDeleteProgram
  "glDeleteProgram"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glDeleteProgram"))
      (paramdef "GLuint " (parameter "program"))))
  '(*fragment*
     (heading "Deletes a program object")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "program")))
                   (para "Specifies the program object to be
\t\t    deleted.")))
     (heading "Description")
     (para (code "glDeleteProgram")
           " frees the memory and
\tinvalidates the name associated with the program object
\tspecified by "
           (var "program.")
           " This command
\teffectively undoes the effects of a call to\t"
           (code "glCreateProgram")
           ".")
     (para "If a program object is in use as part of current rendering
\tstate, it will be flagged for deletion, but it will not be
\tdeleted until it is no longer part of current state for any
\trendering context. If a program object to be deleted has shader
\tobjects attached to it, those shader objects will be
\tautomatically detached but not deleted unless they have already
\tbeen flagged for deletion by a previous call to\t"
           (code "glDeleteShader")
           ".
\tA value of 0 for "
           (var "program")
           " will be silently
\tignored.")
     (para "To determine whether a program object has been flagged for
\tdeletion, call\t"
           (code "glGetProgram")
           "
with arguments "
           (var "program")
           " and\t"
           (code "GL_DELETE_STATUS")
           ".")
     (heading "Errors")
     (para (code "GL_INVALID_VALUE")
           " is generated if\t"
           (var "program")
           " is not a value generated by
\tOpenGL.")
     (para (code "GL_INVALID_OPERATION")
           " is generated if\t"
           (code "glDeleteProgram")
           " is executed between the
\texecution of\t"
           (code "glBegin")
           "
and the corresponding execution of\t"
           (code "glEnd")
           ".")))

(define-gl-procedure
  glDeleteQueries
  "glDeleteQueries"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glDeleteQueries"))
      (paramdef "GLsizei " (parameter "n"))
      (paramdef "const GLuint * " (parameter "ids"))))
  '(*fragment*
     (heading "delete named query objects")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "n")))
                   (para "
Specifies the number of query objects to be deleted. "))
            (entry (% (heading (var "ids")))
                   (para "
Specifies an array of query objects to be deleted. ")))
     (heading "Description")
     (para (code "glDeleteQueries")
           " deletes "
           (var "n")
           " query objects named by the elements of the array "
           (var "ids")
           ".
            After a query object is deleted, it has no contents,
            and its name is free for reuse (for example by "
           (code "glGenQueries")
           "). ")
     (para (code "glDeleteQueries")
           " silently ignores 0's and names that do not correspond to
            existing query objects. ")
     (heading "Errors")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "n")
           " is negative. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glDeleteQueries")
           " is executed
            between the execution of "
           (code "glBegin")
           " and the corresponding
            execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glDeleteShader
  "glDeleteShader"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glDeleteShader"))
      (paramdef "GLuint " (parameter "shader"))))
  '(*fragment*
     (heading "Deletes a shader object")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "shader")))
                   (para "Specifies the shader object to be deleted.")))
     (heading "Description")
     (para (code "glDeleteShader")
           " frees the memory and
\tinvalidates the name associated with the shader object specified
\tby "
           (var "shader")
           ". This command effectively
\tundoes the effects of a call to\t"
           (code "glCreateShader")
           ".")
     (para "If a shader object to be deleted is attached to a program
\tobject, it will be flagged for deletion, but it will not be
\tdeleted until it is no longer attached to any program object,
\tfor any rendering context (i.e., it must be detached from
\twherever it was attached before it will be deleted). A value of
\t0 for "
           (var "shader")
           " will be silently
\tignored.")
     (para "To determine whether an object has been flagged for
\tdeletion, call\t"
           (code "glGetShader")
           "
with arguments "
           (var "shader")
           " and\t"
           (code "GL_DELETE_STATUS")
           ".")
     (heading "Errors")
     (para (code "GL_INVALID_VALUE")
           " is generated if\t"
           (var "shader")
           " is not a value generated by
\tOpenGL.")
     (para (code "GL_INVALID_OPERATION")
           " is generated if\t"
           (code "glDeleteShader")
           " is executed between the
\texecution of\t"
           (code "glBegin")
           "
and the corresponding execution of\t"
           (code "glEnd")
           ".")))

(define-gl-procedure
  glDeleteTextures
  "glDeleteTextures"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glDeleteTextures"))
      (paramdef "GLsizei " (parameter "n"))
      (paramdef
        "const GLuint * "
        (parameter "textures"))))
  '(*fragment*
     (heading "delete named textures")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "n")))
                   (para "
Specifies the number of textures to be deleted. "))
            (entry (% (heading (var "textures")))
                   (para "
Specifies an array of textures to be deleted. ")))
     (heading "Description")
     (para (code "glDeleteTextures")
           " deletes "
           (var "n")
           " textures named by the elements of the array "
           (var "textures")
           ".
            After a texture is deleted, it has no contents or dimensionality,
            and its name is free for reuse (for example by "
           (code "glGenTextures")
           ").
            If a texture that is currently bound is deleted, the binding reverts
            to 0 (the default texture). ")
     (para (code "glDeleteTextures")
           " silently ignores 0's and names that do not correspond to
            existing textures. ")
     (heading "Errors")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "n")
           " is negative. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glDeleteTextures")
           " is executed
            between the execution of "
           (code "glBegin")
           " and the corresponding
            execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glDepthFunc
  "glDepthFunc"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glDepthFunc"))
      (paramdef "GLenum " (parameter "func"))))
  '(*fragment*
     (heading
       "specify the value used for depth buffer comparisons")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "func")))
                   (para "
Specifies the depth comparison function.
                    Symbolic constants "
                         (code "GL_NEVER")
                         ", "
                         (code "GL_LESS")
                         ", "
                         (code "GL_EQUAL")
                         ", "
                         (code "GL_LEQUAL")
                         ", "
                         (code "GL_GREATER")
                         ", "
                         (code "GL_NOTEQUAL")
                         ", "
                         (code "GL_GEQUAL")
                         ", and "
                         (code "GL_ALWAYS")
                         " are accepted.
                    The initial value is "
                         (code "GL_LESS")
                         ". ")))
     (heading "Description")
     (para (code "glDepthFunc")
           " specifies the function used to compare each incoming pixel depth value
            with the depth value present in the depth buffer.
            The comparison is performed only if depth testing is enabled.
            (See "
           (code "glEnable")
           " and "
           (code "glDisable")
           " of "
           (code "GL_DEPTH_TEST")
           ".) ")
     (para (var "func")
           " specifies the conditions under which the pixel will be drawn.
            The comparison functions are as follows: ")
     (table (% (formatter (asis)))
            (entry (% (heading (code "GL_NEVER")))
                   (para "
Never passes. "))
            (entry (% (heading (code "GL_LESS")))
                   (para "
Passes if the incoming depth value is less than the stored depth value. "))
            (entry (% (heading (code "GL_EQUAL")))
                   (para "
Passes if the incoming depth value is equal to the stored depth value. "))
            (entry (% (heading (code "GL_LEQUAL")))
                   (para "
Passes if the incoming depth value is less than or equal to
                        the stored depth value. "))
            (entry (% (heading (code "GL_GREATER")))
                   (para "
Passes if the incoming depth value is greater than the stored depth value. "))
            (entry (% (heading (code "GL_NOTEQUAL")))
                   (para "
Passes if the incoming depth value is not equal to the stored depth value. "))
            (entry (% (heading (code "GL_GEQUAL")))
                   (para "
Passes if the incoming depth value is greater than or equal to
                        the stored depth value. "))
            (entry (% (heading (code "GL_ALWAYS")))
                   (para "
Always passes. ")))
     (para "
The initial value of "
           (var "func")
           " is "
           (code "GL_LESS")
           ".
            Initially, depth testing is disabled.  If depth testing is disabled or if no
            depth buffer exists, it is as if the depth test always passes. ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "func")
           " is not an accepted value. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glDepthFunc")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glDepthMask
  "glDepthMask"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glDepthMask"))
      (paramdef "GLboolean " (parameter "flag"))))
  '(*fragment*
     (heading
       "enable or disable writing into the depth buffer")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "flag")))
                   (para "
Specifies whether the depth buffer is enabled for writing.
                    If "
                         (var "flag")
                         " is "
                         (code "GL_FALSE")
                         ",
                    depth buffer writing is disabled.
                    Otherwise, it is enabled.
                    Initially, depth buffer writing is enabled. ")))
     (heading "Description")
     (para (code "glDepthMask")
           " specifies whether the depth buffer is enabled for writing.
            If "
           (var "flag")
           " is "
           (code "GL_FALSE")
           ",
            depth buffer writing is disabled.
            Otherwise, it is enabled.
            Initially, depth buffer writing is enabled. ")
     (heading "Errors")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glDepthMask")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glDepthRange
  "glDepthRange"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glDepthRange"))
      (paramdef "GLclampd " (parameter "nearVal"))
      (paramdef "GLclampd " (parameter "farVal"))))
  '(*fragment*
     (heading
       "specify mapping of depth values from normalized device coordinates to window coordinates")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "nearVal")))
                   (para "
Specifies the mapping of the near clipping plane to window coordinates.
                    The initial value is 0. "))
            (entry (% (heading (var "farVal")))
                   (para "
Specifies the mapping of the far clipping plane to window coordinates.
                    The initial value is 1. ")))
     (heading "Description")
     (para "
After clipping and division by "
           (var "w")
           ",
            depth coordinates range from "
           (math "-1")
           "
to 1,
            corresponding to the near and far clipping planes. "
           (code "glDepthRange")
           " specifies a linear mapping of the normalized depth coordinates
            in this range to window depth coordinates.
            Regardless of the actual depth buffer implementation,
            window coordinate depth values are treated as though they range
            from 0 through 1 (like color components).
            Thus,
            the values accepted by "
           (code "glDepthRange")
           " are both clamped to this range
            before they are accepted. ")
     (para "
The setting of (0,1) maps the near plane to 0 and
            the far plane to 1.
            With this mapping,
            the depth buffer range is fully utilized. ")
     (heading "Errors")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glDepthRange")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glDetachShader
  "glDetachShader"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glDetachShader"))
      (paramdef "GLuint " (parameter "program"))
      (paramdef "GLuint " (parameter "shader"))))
  '(*fragment*
     (heading
       "Detaches a shader object from a program object to which it is attached")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "program")))
                   (para "Specifies the program object from which to
\t\t    detach the shader object."))
            (entry (% (heading (var "shader")))
                   (para "Specifies the shader object to be
\t\t    detached.")))
     (heading "Description")
     (para (code "glDetachShader")
           " detaches the shader
\tobject specified by "
           (var "shader")
           " from the
\tprogram object specified by "
           (var "program")
           ". This
\tcommand can be used to undo the effect of the command\t"
           (code "glAttachShader")
           ".")
     (para "If "
           (var "shader")
           " has already been flagged
\tfor deletion by a call to\t"
           (code "glDeleteShader")
           "
and it is not attached to any other program object, it will be
\tdeleted after it has been detached.")
     (heading "Errors")
     (para (code "GL_INVALID_VALUE")
           " is generated if either\t"
           (var "program")
           " or "
           (var "shader")
           "
is a value that was not generated by OpenGL.")
     (para (code "GL_INVALID_OPERATION")
           " is generated if\t"
           (var "program")
           " is not a program object.")
     (para (code "GL_INVALID_OPERATION")
           " is generated if\t"
           (var "shader")
           " is not a shader object.")
     (para (code "GL_INVALID_OPERATION")
           " is generated if\t"
           (var "shader")
           " is not attached to\t"
           (var "program")
           ".")
     (para (code "GL_INVALID_OPERATION")
           " is generated if\t"
           (code "glDetachShader")
           " is executed between the
\texecution of\t"
           (code "glBegin")
           "
and the corresponding execution of\t"
           (code "glEnd")
           ".")))

(define-gl-procedure
  glDrawArrays
  "glDrawArrays"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glDrawArrays"))
      (paramdef "GLenum " (parameter "mode"))
      (paramdef "GLint " (parameter "first"))
      (paramdef "GLsizei " (parameter "count"))))
  '(*fragment*
     (heading "render primitives from array data")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "mode")))
                   (para "
Specifies what kind of primitives to render.
                    Symbolic constants "
                         (code "GL_POINTS")
                         ", "
                         (code "GL_LINE_STRIP")
                         ", "
                         (code "GL_LINE_LOOP")
                         ", "
                         (code "GL_LINES")
                         ", "
                         (code "GL_TRIANGLE_STRIP")
                         ", "
                         (code "GL_TRIANGLE_FAN")
                         ", "
                         (code "GL_TRIANGLES")
                         ", "
                         (code "GL_QUAD_STRIP")
                         ", "
                         (code "GL_QUADS")
                         ",
                    and "
                         (code "GL_POLYGON")
                         " are accepted. "))
            (entry (% (heading (var "first")))
                   (para "
Specifies the starting index in the enabled arrays. "))
            (entry (% (heading (var "count")))
                   (para "
Specifies the number of indices to be rendered. ")))
     (heading "Description")
     (para (code "glDrawArrays")
           " specifies multiple geometric primitives
            with very few subroutine calls. Instead of calling a GL procedure
            to pass each individual vertex, normal, texture coordinate, edge
            flag, or color, you can prespecify
            separate arrays of vertices, normals, and colors and use them to
            construct a sequence of primitives with a single
            call to "
           (code "glDrawArrays")
           ". ")
     (para "
When "
           (code "glDrawArrays")
           " is called, it uses "
           (var "count")
           " sequential elements from each
            enabled array to construct a sequence of geometric primitives,
            beginning with element "
           (var "first")
           ". "
           (var "mode")
           " specifies what kind of
            primitives are constructed and how the array elements
            construct those primitives. If "
           (code "GL_VERTEX_ARRAY")
           " is not enabled, no
            geometric primitives are generated. ")
     (para "
Vertex attributes that are modified by "
           (code "glDrawArrays")
           " have an
            unspecified value after "
           (code "glDrawArrays")
           " returns. For example, if "
           (code "GL_COLOR_ARRAY")
           " is enabled, the value of the current color is
            undefined after "
           (code "glDrawArrays")
           " executes. Attributes that aren't
            modified remain well defined. ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "mode")
           " is not an accepted value. ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "count")
           " is negative. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to an
            enabled array and the buffer object's data store is currently mapped. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glDrawArrays")
           " is executed between
            the execution of "
           (code "glBegin")
           " and the corresponding "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glDrawBuffers
  "glDrawBuffers"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glDrawBuffers"))
      (paramdef "GLsizei " (parameter "n"))
      (paramdef "const GLenum *" (parameter "bufs"))))
  '(*fragment*
     (heading
       "Specifies a list of color buffers to be drawn into")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "n")))
                   (para "Specifies the number of buffers in "
                         (var "bufs")
                         "."))
            (entry (% (heading (var "bufs")))
                   (para "Points to an array of symbolic constants
\t\t    specifying the buffers into which fragment colors or
\t\t    data values will be written.")))
     (heading "Description")
     (para (code "glDrawBuffers")
           " defines an array of
\tbuffers into which fragment color values or fragment data will
\tbe written. If no fragment shader is active, rendering
\toperations will generate only one fragment color per fragment
\tand it will be written into each of the buffers specified by\t"
           (var "bufs")
           ". If a fragment shader is active and
\tit writes a value to the output variable\t"
           (code "gl_FragColor")
           ", then that value will be
\twritten into each of the buffers specified by\t"
           (var "bufs")
           ". If a fragment shader is active and
\tit writes a value to one or more elements of the output array
\tvariable "
           (code "gl_FragData[]")
           ", then the value of\t"
           (code "gl_FragData[0] ")
           " will be written into the
\tfirst buffer specified by "
           (var "bufs")
           ", the value
\tof "
           (code "gl_FragData[1] ")
           " will be written into the
\tsecond buffer specified by "
           (var "bufs")
           ", and so
\ton up to "
           (code "gl_FragData[n-1]")
           ". The draw buffer
\tused for "
           (code "gl_FragData[n]")
           " and beyond is
\timplicitly set to be "
           (code "GL_NONE")
           ".")
     (para "The symbolic constants contained in\t"
           (var "bufs")
           " may be any of the following:")
     (table (% (formatter (asis)))
            (entry (% (heading (code "GL_NONE")))
                   (para "The fragment color/data value is not written into
\t\t    any color buffer."))
            (entry (% (heading (code "GL_FRONT_LEFT")))
                   (para "The fragment color/data value is written into the
\t\t    front left color buffer."))
            (entry (% (heading (code "GL_FRONT_RIGHT")))
                   (para "The fragment color/data value is written into the
\t\t    front right color buffer."))
            (entry (% (heading (code "GL_BACK_LEFT")))
                   (para "The fragment color/data value is written into the
\t\t    back left color buffer."))
            (entry (% (heading (code "GL_BACK_RIGHT")))
                   (para "The fragment color/data value is written into the
\t\t    back right color buffer."))
            (entry (% (heading (code "GL_AUXi")))
                   (para "The fragment color/data value is written into
\t\t    auxiliary buffer "
                         (code "i")
                         ".")))
     (para "Except for "
           (code "GL_NONE")
           ", the preceding
\tsymbolic constants may not appear more than once in\t"
           (var "bufs")
           ". The maximum number of draw buffers
\tsupported is implementation dependent and can be queried by
\tcalling\t"
           (code "glGet")
           "
with the argument "
           (code "GL_MAX_DRAW_BUFFERS")
           ". The
\tnumber of auxiliary buffers can be queried by calling\t"
           (code "glGet")
           "
with the argument "
           (code "GL_AUX_BUFFERS")
           ".")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if one of the
\tvalues in "
           (var "bufs")
           " is not an accepted
\tvalue.")
     (para (code "GL_INVALID_ENUM")
           " is generated if\t"
           (var "n")
           " is less than 0.")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a
\tsymbolic constant other than "
           (code "GL_NONE")
           "
appears more than once in "
           (var "bufs")
           ".")
     (para (code "GL_INVALID_OPERATION")
           " is generated if any of
\tthe entries in "
           (var "bufs")
           " (other than\t"
           (code "GL_NONE")
           " ) indicates a color buffer that
\tdoes not exist in the current GL context.")
     (para (code "GL_INVALID_VALUE")
           " is generated if\t"
           (var "n")
           " is greater than\t"
           (code "GL_MAX_DRAW_BUFFERS")
           ".")
     (para (code "GL_INVALID_OPERATION")
           " is generated if\t"
           (code "glDrawBuffers")
           " is executed between the
\texecution of\t"
           (code "glBegin")
           "
and the corresponding execution of\t"
           (code "glEnd")
           ".")))

(define-gl-procedure
  glDrawBuffer
  "glDrawBuffer"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glDrawBuffer"))
      (paramdef "GLenum " (parameter "mode"))))
  '(*fragment*
     (heading
       "specify which color buffers are to be drawn into")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "mode")))
                   (para "
Specifies up to four color buffers to be drawn into.
                    Symbolic constants "
                         (code "GL_NONE")
                         ", "
                         (code "GL_FRONT_LEFT")
                         ", "
                         (code "GL_FRONT_RIGHT")
                         ", "
                         (code "GL_BACK_LEFT")
                         ", "
                         (code "GL_BACK_RIGHT")
                         ", "
                         (code "GL_FRONT")
                         ", "
                         (code "GL_BACK")
                         ", "
                         (code "GL_LEFT")
                         ", "
                         (code "GL_RIGHT")
                         ", "
                         (code "GL_FRONT_AND_BACK")
                         ", and "
                         (code "GL_AUX")
                         (var "i")
                         ",
                    where "
                         (var "i")
                         " is between 0 and the value of "
                         (code "GL_AUX_BUFFERS")
                         " minus 1,
                    are accepted.  ("
                         (code "GL_AUX_BUFFERS")
                         " is not the upper limit; use "
                         (code "glGet")
                         "
to query the number of available aux buffers.)
                    The initial value is "
                         (code "GL_FRONT")
                         " for single-buffered contexts,
                    and "
                         (code "GL_BACK")
                         " for double-buffered contexts. ")))
     (heading "Description")
     (para "
When colors are written to the frame buffer,
            they are written into the color buffers specified by "
           (code "glDrawBuffer")
           ".
            The specifications are as follows: ")
     (table (% (formatter (asis)))
            (entry (% (heading (code "GL_NONE")))
                   (para "
No color buffers are written. "))
            (entry (% (heading (code "GL_FRONT_LEFT")))
                   (para "
Only the front left color buffer is written. "))
            (entry (% (heading (code "GL_FRONT_RIGHT")))
                   (para "
Only the front right color buffer is written. "))
            (entry (% (heading (code "GL_BACK_LEFT")))
                   (para "
Only the back left color buffer is written. "))
            (entry (% (heading (code "GL_BACK_RIGHT")))
                   (para "
Only the back right color buffer is written. "))
            (entry (% (heading (code "GL_FRONT")))
                   (para "
Only the front left and front right color buffers are written.
                        If there is no front right color buffer,
                        only the front left color buffer is written. "))
            (entry (% (heading (code "GL_BACK")))
                   (para "
Only the back left and back right color buffers are written.
                        If there is no back right color buffer,
                        only the back left color buffer is written. "))
            (entry (% (heading (code "GL_LEFT")))
                   (para "
Only the front left and back left color buffers are written.
                        If there is no back left color buffer,
                        only the front left color buffer is written. "))
            (entry (% (heading (code "GL_RIGHT")))
                   (para "
Only the front right and back right color buffers are written.
                        If there is no back right color buffer,
                        only the front right color buffer is written. "))
            (entry (% (heading (code "GL_FRONT_AND_BACK")))
                   (para "
All the front and back color buffers
                        (front left, front right, back left, back right)
                        are written.
                        If there are no back color buffers,
                        only the front left and front right color buffers are written.
                        If there are no right color buffers,
                        only the front left and back left color buffers are written.
                        If there are no right or back color buffers,
                        only the front left color buffer is written. "))
            (entry (% (heading (code "GL_AUX") (var "i")))
                   (para "
Only auxiliary color buffer "
                         (var "i")
                         " is written. ")))
     (para "
If more than one color buffer is selected for drawing,
            then blending or logical operations are computed and applied independently
            for each color buffer and can produce different results in each buffer. ")
     (para "
Monoscopic contexts include only "
           (var "left")
           "
buffers, and stereoscopic contexts include both "
           (var "left")
           "
and "
           (var "right")
           "
buffers.
            Likewise, single-buffered contexts include only "
           (var "front")
           "
buffers, and double-buffered contexts include both "
           (var "front")
           "
and "
           (var "back")
           "
buffers.
            The context is selected at GL initialization. ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "mode")
           " is not an accepted value. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if none of the buffers indicated
            by "
           (var "mode")
           " exists. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glDrawBuffer")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glDrawElements
  "glDrawElements"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glDrawElements"))
      (paramdef "GLenum " (parameter "mode"))
      (paramdef "GLsizei " (parameter "count"))
      (paramdef "GLenum " (parameter "type"))
      (paramdef
        "const GLvoid * "
        (parameter "indices"))))
  '(*fragment*
     (heading "render primitives from array data")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "mode")))
                   (para "
Specifies what kind of primitives to render.
                    Symbolic constants "
                         (code "GL_POINTS")
                         ", "
                         (code "GL_LINE_STRIP")
                         ", "
                         (code "GL_LINE_LOOP")
                         ", "
                         (code "GL_LINES")
                         ", "
                         (code "GL_TRIANGLE_STRIP")
                         ", "
                         (code "GL_TRIANGLE_FAN")
                         ", "
                         (code "GL_TRIANGLES")
                         ", "
                         (code "GL_QUAD_STRIP")
                         ", "
                         (code "GL_QUADS")
                         ",
                    and "
                         (code "GL_POLYGON")
                         " are accepted. "))
            (entry (% (heading (var "count")))
                   (para "
Specifies the number of elements to be rendered. "))
            (entry (% (heading (var "type")))
                   (para "
Specifies the type of the values in "
                         (var "indices")
                         ". Must be one of "
                         (code "GL_UNSIGNED_BYTE")
                         ", "
                         (code "GL_UNSIGNED_SHORT")
                         ", or "
                         (code "GL_UNSIGNED_INT")
                         ". "))
            (entry (% (heading (var "indices")))
                   (para "
Specifies a pointer to the location where the indices are stored. ")))
     (heading "Description")
     (para (code "glDrawElements")
           " specifies multiple geometric primitives
            with very few subroutine calls. Instead of calling a GL function
            to pass each individual vertex, normal, texture coordinate, edge
            flag, or color, you can prespecify
            separate arrays of vertices, normals, and so on, and use them to
            construct a sequence of primitives with a single
            call to "
           (code "glDrawElements")
           ". ")
     (para "
When "
           (code "glDrawElements")
           " is called, it uses "
           (var "count")
           " sequential elements from an
            enabled array, starting at "
           (var "indices")
           " to construct a sequence of
            geometric primitives. "
           (var "mode")
           " specifies what kind of primitives are
            constructed and how the array elements construct these primitives. If
            more than one array is enabled, each is used. If "
           (code "GL_VERTEX_ARRAY")
           " is not enabled, no geometric primitives are
            constructed. ")
     (para "
Vertex attributes that are modified by "
           (code "glDrawElements")
           " have an
            unspecified value after "
           (code "glDrawElements")
           " returns. For example, if "
           (code "GL_COLOR_ARRAY")
           " is enabled, the value of the current color is
            undefined after "
           (code "glDrawElements")
           " executes. Attributes that aren't
            modified maintain their previous values. ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "mode")
           " is not an accepted value. ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "count")
           " is negative. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to an
            enabled array or the element array and the buffer object's data store is currently mapped. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glDrawElements")
           " is executed between
            the execution of "
           (code "glBegin")
           " and the corresponding "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glDrawPixels
  "glDrawPixels"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glDrawPixels"))
      (paramdef "GLsizei " (parameter "width"))
      (paramdef "GLsizei " (parameter "height"))
      (paramdef "GLenum " (parameter "format"))
      (paramdef "GLenum " (parameter "type"))
      (paramdef "const GLvoid * " (parameter "data"))))
  '(*fragment*
     (heading
       "write a block of pixels to the frame buffer")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "width")))
                   (itemx (var "height"))
                   (para "
Specify the dimensions of the pixel rectangle to be written
                    into the frame buffer. "))
            (entry (% (heading (var "format")))
                   (para "
Specifies the format of the pixel data.
                    Symbolic constants "
                         (code "GL_COLOR_INDEX")
                         ", "
                         (code "GL_STENCIL_INDEX")
                         ", "
                         (code "GL_DEPTH_COMPONENT")
                         ", "
                         (code "GL_RGB")
                         ", "
                         (code "GL_BGR")
                         ", "
                         (code "GL_RGBA")
                         ", "
                         (code "GL_BGRA")
                         ", "
                         (code "GL_RED")
                         ", "
                         (code "GL_GREEN")
                         ", "
                         (code "GL_BLUE")
                         ", "
                         (code "GL_ALPHA")
                         ", "
                         (code "GL_LUMINANCE")
                         ", and "
                         (code "GL_LUMINANCE_ALPHA")
                         " are accepted. "))
            (entry (% (heading (var "type")))
                   (para "
Specifies the data type for "
                         (var "data")
                         ".
                    Symbolic constants "
                         (code "GL_UNSIGNED_BYTE")
                         ", "
                         (code "GL_BYTE")
                         ", "
                         (code "GL_BITMAP")
                         ", "
                         (code "GL_UNSIGNED_SHORT")
                         ", "
                         (code "GL_SHORT")
                         ", "
                         (code "GL_UNSIGNED_INT")
                         ", "
                         (code "GL_INT")
                         ", "
                         (code "GL_FLOAT")
                         ", "
                         (code "GL_UNSIGNED_BYTE_3_3_2")
                         ", "
                         (code "GL_UNSIGNED_BYTE_2_3_3_REV")
                         ", "
                         (code "GL_UNSIGNED_SHORT_5_6_5")
                         ", "
                         (code "GL_UNSIGNED_SHORT_5_6_5_REV")
                         ", "
                         (code "GL_UNSIGNED_SHORT_4_4_4_4")
                         ", "
                         (code "GL_UNSIGNED_SHORT_4_4_4_4_REV")
                         ", "
                         (code "GL_UNSIGNED_SHORT_5_5_5_1")
                         ", "
                         (code "GL_UNSIGNED_SHORT_1_5_5_5_REV")
                         ", "
                         (code "GL_UNSIGNED_INT_8_8_8_8")
                         ", "
                         (code "GL_UNSIGNED_INT_8_8_8_8_REV")
                         ", "
                         (code "GL_UNSIGNED_INT_10_10_10_2")
                         ", and "
                         (code "GL_UNSIGNED_INT_2_10_10_10_REV")
                         "
are accepted. "))
            (entry (% (heading (var "data")))
                   (para "
Specifies a pointer to the pixel data. ")))
     (heading "Description")
     (para (code "glDrawPixels")
           " reads pixel data from memory and writes it into the frame buffer
            relative to the current raster position, provided that the raster
            position is valid.  Use "
           (code "glRasterPos")
           " or "
           (code "glWindowPos")
           " to set the current raster position; use "
           (code "glGet")
           " with argument "
           (code "GL_CURRENT_RASTER_POSITION_VALID")
           "
to determine if the specified raster position is valid, and "
           (code "glGet")
           " with argument "
           (code "GL_CURRENT_RASTER_POSITION")
           "
to query the raster position. ")
     (para "
Several parameters define the encoding of pixel data in memory
            and control the processing of the pixel data
            before it is placed in the frame buffer.
            These parameters are set with four commands: "
           (code "glPixelStore")
           ", "
           (code "glPixelTransfer")
           ", "
           (code "glPixelMap")
           ", and "
           (code "glPixelZoom")
           ".
            This reference page describes the effects on "
           (code "glDrawPixels")
           " of many,
            but not all, of the parameters specified by these four commands. ")
     (para "
Data is read from "
           (var "data")
           " as a sequence of signed or unsigned bytes,
            signed or unsigned shorts, signed or unsigned integers, or
            single-precision floating-point values, depending on "
           (var "type")
           ".
            When "
           (var "type")
           " is one of "
           (code "GL_UNSIGNED_BYTE")
           ", "
           (code "GL_BYTE")
           ", "
           (code "GL_UNSIGNED_SHORT")
           ", "
           (code "GL_SHORT")
           ", "
           (code "GL_UNSIGNED_INT")
           ", "
           (code "GL_INT")
           ", or "
           (code "GL_FLOAT")
           " each of these bytes, shorts, integers, or
            floating-point values is interpreted as one color or depth component, or
            one index, depending on "
           (var "format")
           ".
            When "
           (var "type")
           " is one of "
           (code "GL_UNSIGNED_BYTE_3_3_2")
           ", "
           (code "GL_UNSIGNED_SHORT_5_6_5")
           ", "
           (code "GL_UNSIGNED_SHORT_4_4_4_4")
           ", "
           (code "GL_UNSIGNED_SHORT_5_5_5_1")
           ", "
           (code "GL_UNSIGNED_INT_8_8_8_8")
           ", or "
           (code "GL_UNSIGNED_INT_10_10_10_2")
           ", each unsigned value is interpreted as
            containing all the components for a single pixel, with the color
            components arranged according to "
           (var "format")
           ".
            When "
           (var "type")
           " is one of "
           (code "GL_UNSIGNED_BYTE_2_3_3_REV")
           ", "
           (code "GL_UNSIGNED_SHORT_5_6_5_REV")
           ", "
           (code "GL_UNSIGNED_SHORT_4_4_4_4_REV")
           ", "
           (code "GL_UNSIGNED_SHORT_1_5_5_5_REV")
           ", "
           (code "GL_UNSIGNED_INT_8_8_8_8_REV")
           ", or "
           (code "GL_UNSIGNED_INT_2_10_10_10_REV")
           ", each unsigned value is interpreted
            as containing all color components, specified by "
           (var "format")
           ", for a single
            pixel in a reversed order. Indices are always treated individually.
            Color components are treated as groups of one, two, three, or four
            values, again based on "
           (var "format")
           ". Both individual indices and groups of
            components are referred to as pixels.
            If "
           (var "type")
           " is "
           (code "GL_BITMAP")
           ", the data must be unsigned bytes, and "
           (var "format")
           " must be either "
           (code "GL_COLOR_INDEX")
           " or "
           (code "GL_STENCIL_INDEX")
           ".
            Each unsigned byte is treated as eight 1-bit pixels, with bit ordering
            determined by "
           (code "GL_UNPACK_LSB_FIRST")
           " (see "
           (code "glPixelStore")
           "). ")
     (para (math (var "width") "×" (var "height"))
           "
pixels are read from memory,
            starting at location "
           (var "data")
           ".
            By default, these pixels are taken from adjacent memory locations,
            except that after all "
           (var "width")
           " pixels are read,
            the read pointer is advanced to the next four-byte boundary.
            The four-byte row alignment is specified by "
           (code "glPixelStore")
           " with
            argument "
           (code "GL_UNPACK_ALIGNMENT")
           ",
            and it can be set to one, two, four, or eight bytes.
            Other pixel store parameters specify different read pointer advancements,
            both before the first pixel is read
            and after all "
           (var "width")
           " pixels are read.
            See the "
           (code "glPixelStore")
           " reference page for details on these options. ")
     (para "
If a non-zero named buffer object is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target 
            (see "
           (code "glBindBuffer")
           ") while a block of pixels is
            specified, "
           (var "data")
           " is treated as a byte offset into the buffer object's data store. ")
     (para "
The "
           (math (var "width") "×" (var "height"))
           "
pixels that are read from memory are
            each operated on in the same way,
            based on the values of several parameters specified by "
           (code "glPixelTransfer")
           "
and "
           (code "glPixelMap")
           ".
            The details of these operations,
            as well as the target buffer into which the pixels are drawn,
            are specific to the format of the pixels,
            as specified by "
           (var "format")
           ". "
           (var "format")
           " can assume one of 13 symbolic values: ")
     (table (% (formatter (asis)))
            (entry (% (heading (code "GL_COLOR_INDEX")))
                   (para "
Each pixel is a single value,
                        a color index.
                        It is converted to fixed-point format,
                        with an unspecified number of bits to the right of the binary point,
                        regardless of the memory data type.
                        Floating-point values convert to true fixed-point values.
                        Signed and unsigned integer data is converted with all fraction bits
                        set to 0.
                        Bitmap data convert to either 0 or 1. ")
                   (para "
Each fixed-point index is then shifted left by "
                         (code "GL_INDEX_SHIFT")
                         " bits
                        and added to "
                         (code "GL_INDEX_OFFSET")
                         ".
                        If "
                         (code "GL_INDEX_SHIFT")
                         " is negative,
                        the shift is to the right.
                        In either case, zero bits fill otherwise unspecified bit locations in the
                        result. ")
                   (para "
If the GL is in RGBA mode,
                        the resulting index is converted to an RGBA pixel
                        with the help of the "
                         (code "GL_PIXEL_MAP_I_TO_R")
                         ", "
                         (code "GL_PIXEL_MAP_I_TO_G")
                         ", "
                         (code "GL_PIXEL_MAP_I_TO_B")
                         ",
                        and "
                         (code "GL_PIXEL_MAP_I_TO_A")
                         " tables.
                        If the GL is in color index mode,
                        and if "
                         (code "GL_MAP_COLOR")
                         " is true,
                        the index is replaced with the value that it references in lookup table "
                         (code "GL_PIXEL_MAP_I_TO_I")
                         ".
                        Whether the lookup replacement of the index is done or not,
                        the integer part of the index is then ANDed with "
                         (math "2" "^" (var "b") "-" "1")
                         ",
                        where "
                         (math (var "b"))
                         "
is the number of bits in a color index buffer. ")
                   (para "
The GL then converts the resulting indices or RGBA colors to fragments
                        by attaching the current raster position "
                         (var "z")
                         " coordinate and
                        texture coordinates to each pixel,
                        then assigning "
                         (math (var "x"))
                         "
and "
                         (math (var "y"))
                         "
window coordinates to the "
                         (math (var "n"))
                         "th
                        fragment such that "
                         (math (var "x")
                               "_"
                               (var "n")
                               "="
                               (var "x")
                               "_"
                               (var "r")
                               "+"
                               (var "n")
                               "%"
                               (var "width"))
                         (para (math (var "y")
                                     "_"
                                     (var "n")
                                     "="
                                     (var "y")
                                     "_"
                                     (var "r")
                                     "+"
                                     "⌊"
                                     (var "n")
                                     "/"
                                     (var "width")
                                     ","
                                     "⌋"))
                         (para))
                   (para "
where "
                         (math "("
                               (var "x")
                               "_"
                               (var "r")
                               ","
                               (var "y")
                               "_"
                               (var "r")
                               ")")
                         "
is the current raster position.
                        These pixel fragments are then treated just like the fragments generated by
                        rasterizing points, lines, or polygons.
                        Texture mapping,
                        fog,
                        and all the fragment operations are applied before the fragments are written
                        to the frame buffer. "))
            (entry (% (heading (code "GL_STENCIL_INDEX")))
                   (para "
Each pixel is a single value,
                        a stencil index.
                        It is converted to fixed-point format,
                        with an unspecified number of bits to the right of the binary point,
                        regardless of the memory data type.
                        Floating-point values convert to true fixed-point values.
                        Signed and unsigned integer data is converted with all fraction bits
                        set to 0.
                        Bitmap data convert to either 0 or 1. ")
                   (para "
Each fixed-point index is then shifted left by "
                         (code "GL_INDEX_SHIFT")
                         " bits,
                        and added to "
                         (code "GL_INDEX_OFFSET")
                         ".
                        If "
                         (code "GL_INDEX_SHIFT")
                         " is negative,
                        the shift is to the right.
                        In either case, zero bits fill otherwise unspecified bit locations in the
                        result.
                        If "
                         (code "GL_MAP_STENCIL")
                         " is true,
                        the index is replaced with the value that it references in lookup table "
                         (code "GL_PIXEL_MAP_S_TO_S")
                         ".
                        Whether the lookup replacement of the index is done or not,
                        the integer part of the index is then ANDed with "
                         (math "2" "^" (var "b") "-" "1")
                         ",
                        where "
                         (math (var "b"))
                         "
is the number of bits in the stencil buffer.
                        The resulting stencil indices are then written to the stencil buffer
                        such that the "
                         (math (var "n"))
                         "th
                        index is written to location ")
                   (para (math (var "x")
                               "_"
                               (var "n")
                               "="
                               (var "x")
                               "_"
                               (var "r")
                               "+"
                               (var "n")
                               "%"
                               (var "width"))
                         (para (math (var "y")
                                     "_"
                                     (var "n")
                                     "="
                                     (var "y")
                                     "_"
                                     (var "r")
                                     "+"
                                     "⌊"
                                     (var "n")
                                     "/"
                                     (var "width")
                                     ","
                                     "⌋")))
                   (para "
where "
                         (math "("
                               (var "x")
                               "_"
                               (var "r")
                               ","
                               (var "y")
                               "_"
                               (var "r")
                               ")")
                         "
is the current raster position.
                        Only the pixel ownership test,
                        the scissor test,
                        and the stencil writemask affect these write operations. "))
            (entry (% (heading (code "GL_DEPTH_COMPONENT")))
                   (para "
Each pixel is a single-depth component.
                        Floating-point data is converted directly to an internal floating-point
                        format with unspecified precision.
                        Signed integer data is mapped linearly to the internal floating-point
                        format such that the most positive representable integer value maps to 1.0,
                        and the most negative representable value maps to "
                         (math "-1.0")
                         ".
                        Unsigned integer data is mapped similarly:
                        the largest integer value maps to 1.0,
                        and 0 maps to 0.0.
                        The resulting floating-point depth value is then multiplied
                        by "
                         (code "GL_DEPTH_SCALE")
                         " and added to "
                         (code "GL_DEPTH_BIAS")
                         ".
                        The result is clamped to the range "
                         (math "[" "0" "," "1" "]")
                         ". ")
                   (para "
The GL then converts the resulting depth components to fragments
                        by attaching the current raster position color or color index and
                        texture coordinates to each pixel,
                        then assigning "
                         (math (var "x"))
                         "
and "
                         (math (var "y"))
                         "
window coordinates to the "
                         (math (var "n"))
                         "th
                        fragment such that ")
                   (para (math (var "x")
                               "_"
                               (var "n")
                               "="
                               (var "x")
                               "_"
                               (var "r")
                               "+"
                               (var "n")
                               "%"
                               (var "width"))
                         (para (math (var "y")
                                     "_"
                                     (var "n")
                                     "="
                                     (var "y")
                                     "_"
                                     (var "r")
                                     "+"
                                     "⌊"
                                     (var "n")
                                     "/"
                                     (var "width")
                                     ","
                                     "⌋")))
                   (para "
where "
                         (math "("
                               (var "x")
                               "_"
                               (var "r")
                               ","
                               (var "y")
                               "_"
                               (var "r")
                               ")")
                         "
is the current raster position.
                        These pixel fragments are then treated just like the fragments generated by
                        rasterizing points, lines, or polygons.
                        Texture mapping,
                        fog,
                        and all the fragment operations are applied before the fragments are written
                        to the frame buffer. "))
            (entry (% (heading (code "GL_RGBA"))))
            (entry (% (heading (code "GL_BGRA")))
                   (para "
Each pixel is a four-component group: For "
                         (code "GL_RGBA")
                         ", the red
                        component is first, followed by green, followed by blue, followed by
                        alpha; for "
                         (code "GL_BGRA")
                         " the order is blue, green, red and then alpha.
                        Floating-point values are converted directly to an internal floating-point
                        format with unspecified precision.
                        Signed integer values are mapped linearly to the internal floating-point
                        format such that the most positive representable integer value maps to 1.0,
                        and the most negative representable value maps to "
                         (math "-1.0")
                         ".
                        (Note that
                        this mapping does not convert 0 precisely to 0.0.)
                        Unsigned integer data is mapped similarly:
                        The largest integer value maps to 1.0,
                        and 0 maps to 0.0.
                        The resulting floating-point color values are then multiplied
                        by "
                         (code "GL_c_SCALE")
                         " and added to "
                         (code "GL_c_BIAS")
                         ",
                        where "
                         (var "c")
                         " is RED, GREEN, BLUE, and ALPHA
                        for the respective color components.
                        The results are clamped to the range "
                         (math "[" "0" "," "1" "]")
                         ". ")
                   (para "
If "
                         (code "GL_MAP_COLOR")
                         " is true,
                        each color component is scaled by the size of lookup table "
                         (code "GL_PIXEL_MAP_c_TO_c")
                         ",
                        then replaced by the value that it references in that table. "
                         (var "c")
                         " is R, G, B, or A respectively. ")
                   (para "
The GL then converts the resulting RGBA colors to fragments
                        by attaching the current raster position "
                         (var "z")
                         " coordinate and
                        texture coordinates to each pixel,
                        then assigning "
                         (math (var "x"))
                         "
and "
                         (math (var "y"))
                         "
window coordinates to the "
                         (math (var "n"))
                         "th
                        fragment such that ")
                   (para (math (var "x")
                               "_"
                               (var "n")
                               "="
                               (var "x")
                               "_"
                               (var "r")
                               "+"
                               (var "n")
                               "%"
                               (var "width"))
                         (para (math (var "y")
                                     "_"
                                     (var "n")
                                     "="
                                     (var "y")
                                     "_"
                                     (var "r")
                                     "+"
                                     "⌊"
                                     (var "n")
                                     "/"
                                     (var "width")
                                     ","
                                     "⌋")))
                   (para "
where "
                         (math "("
                               (var "x")
                               "_"
                               (var "r")
                               ","
                               (var "y")
                               "_"
                               (var "r")
                               ")")
                         "
is the current raster position.
                        These pixel fragments are then treated just like the fragments generated by
                        rasterizing points, lines, or polygons.
                        Texture mapping,
                        fog,
                        and all the fragment operations are applied before the fragments are written
                        to the frame buffer. "))
            (entry (% (heading (code "GL_RED")))
                   (para "
Each pixel is a single red component.
                        This component is converted to the internal floating-point format in
                        the same way the red component of an RGBA pixel is. It is
                        then converted to an RGBA pixel with green and blue set to 0,
                        and alpha set to 1.
                        After this conversion, the pixel is treated as if it had been read
                        as an RGBA pixel. "))
            (entry (% (heading (code "GL_GREEN")))
                   (para "
Each pixel is a single green component.
                        This component is converted to the internal floating-point format in
                        the same way the green component of an RGBA pixel is.
                        It is then converted to an RGBA pixel with red and blue set to 0,
                        and alpha set to 1.
                        After this conversion, the pixel is treated as if it had been read
                        as an RGBA pixel. "))
            (entry (% (heading (code "GL_BLUE")))
                   (para "
Each pixel is a single blue component.
                        This component is converted to the internal floating-point format in
                        the same way the blue component of an RGBA pixel is.
                        It is then converted to an RGBA pixel with red and green set to 0,
                        and alpha set to 1.
                        After this conversion, the pixel is treated as if it had been read
                        as an RGBA pixel. "))
            (entry (% (heading (code "GL_ALPHA")))
                   (para "
Each pixel is a single alpha component.
                        This component is converted to the internal floating-point format in
                        the same way the alpha component of an RGBA pixel is.
                        It is then converted to an RGBA pixel with red, green, and blue set to 0.
                        After this conversion, the pixel is treated as if it had been read
                        as an RGBA pixel. "))
            (entry (% (heading (code "GL_RGB"))))
            (entry (% (heading (code "GL_BGR")))
                   (para "
Each pixel is a three-component group:
                        red first, followed by green, followed by blue; for "
                         (code "GL_BGR")
                         ", the
                        first component is blue, followed by green and then red.
                        Each component is converted to the internal floating-point format in
                        the same way the red, green, and blue components of an RGBA pixel are.
                        The color triple is converted to an RGBA pixel with alpha set to 1.
                        After this conversion, the pixel is treated as if it had been read
                        as an RGBA pixel. "))
            (entry (% (heading (code "GL_LUMINANCE")))
                   (para "
Each pixel is a single luminance component.
                        This component is converted to the internal floating-point format in
                        the same way the red component of an RGBA pixel is.
                        It is then converted to an RGBA pixel with red, green, and blue set to the
                        converted luminance value,
                        and alpha set to 1.
                        After this conversion, the pixel is treated as if it had been read
                        as an RGBA pixel. "))
            (entry (% (heading (code "GL_LUMINANCE_ALPHA")))
                   (para "
Each pixel is a two-component group:
                        luminance first, followed by alpha.
                        The two components are converted to the internal floating-point format in
                        the same way the red component of an RGBA pixel is.
                        They are then converted to an RGBA pixel with red, green, and blue set to the
                        converted luminance value,
                        and alpha set to the converted alpha value.
                        After this conversion, the pixel is treated as if it had been read
                        as an RGBA pixel. ")))
     (para "
The following table summarizes the meaning of the valid constants for the "
           (var "type")
           " parameter: ")
     (para)
     (table (% (formatter (asis)))
            (entry (% (heading (strong "Type")))
                   (para (strong "Corresponding Type")))
            (entry (% (heading (code "GL_UNSIGNED_BYTE")))
                   (para "
unsigned 8-bit integer "))
            (entry (% (heading (code "GL_BYTE")))
                   (para "
signed 8-bit integer "))
            (entry (% (heading (code "GL_BITMAP")))
                   (para "
single bits in unsigned 8-bit integers "))
            (entry (% (heading (code "GL_UNSIGNED_SHORT")))
                   (para "
unsigned 16-bit integer "))
            (entry (% (heading (code "GL_SHORT")))
                   (para "
signed 16-bit integer "))
            (entry (% (heading (code "GL_UNSIGNED_INT")))
                   (para "
unsigned 32-bit integer "))
            (entry (% (heading (code "GL_INT")))
                   (para "
32-bit integer "))
            (entry (% (heading (code "GL_FLOAT")))
                   (para "
single-precision floating-point "))
            (entry (% (heading (code "GL_UNSIGNED_BYTE_3_3_2")))
                   (para "
unsigned 8-bit integer "))
            (entry (% (heading (code "GL_UNSIGNED_BYTE_2_3_3_REV")))
                   (para "
unsigned 8-bit integer with reversed component ordering "))
            (entry (% (heading (code "GL_UNSIGNED_SHORT_5_6_5")))
                   (para "
unsigned 16-bit integer "))
            (entry (% (heading (code "GL_UNSIGNED_SHORT_5_6_5_REV")))
                   (para "
unsigned 16-bit integer with reversed component ordering "))
            (entry (% (heading (code "GL_UNSIGNED_SHORT_4_4_4_4")))
                   (para "
unsigned 16-bit integer "))
            (entry (% (heading (code "GL_UNSIGNED_SHORT_4_4_4_4_REV")))
                   (para "
unsigned 16-bit integer with reversed component ordering "))
            (entry (% (heading (code "GL_UNSIGNED_SHORT_5_5_5_1")))
                   (para "
unsigned 16-bit integer "))
            (entry (% (heading (code "GL_UNSIGNED_SHORT_1_5_5_5_REV")))
                   (para "
unsigned 16-bit integer with reversed component ordering "))
            (entry (% (heading (code "GL_UNSIGNED_INT_8_8_8_8")))
                   (para "
unsigned 32-bit integer "))
            (entry (% (heading (code "GL_UNSIGNED_INT_8_8_8_8_REV")))
                   (para "
unsigned 32-bit integer with reversed component ordering "))
            (entry (% (heading (code "GL_UNSIGNED_INT_10_10_10_2")))
                   (para "
unsigned 32-bit integer "))
            (entry (% (heading (code "GL_UNSIGNED_INT_2_10_10_10_REV")))
                   (para "
unsigned 32-bit integer with reversed component ordering ")))
     (para)
     (para "
The rasterization described so far assumes pixel zoom factors of 1.
            If "
           (code "glPixelZoom")
           " is used to change the "
           (math (var "x"))
           "
and "
           (math (var "y"))
           "
pixel zoom factors,
            pixels are converted to fragments as follows.
            If "
           (math "("
                 (var "x")
                 "_"
                 (var "r")
                 ","
                 (var "y")
                 "_"
                 (var "r")
                 ")")
           "
is the current raster position,
            and a given pixel is in the "
           (math (var "n"))
           "th
            column and "
           (math (var "m"))
           "th
            row
            of the pixel rectangle,
            then fragments are generated for pixels whose centers are in the rectangle
            with corners at ")
     (para (math "("
                 (var "x")
                 "_"
                 (var "r")
                 "+"
                 (var "zoom")
                 "_"
                 (var "x")
                 ","
                 "\u2062"
                 (var "n")
                 ","
                 (var "y")
                 "_"
                 (var "r")
                 "+"
                 (var "zoom")
                 "_"
                 (var "y")
                 ","
                 "\u2062"
                 (var "m")
                 ")")
           (para (math "("
                       (var "x")
                       "_"
                       (var "r")
                       "+"
                       (var "zoom")
                       "_"
                       (var "x")
                       ","
                       "\u2061"
                       "("
                       (var "n")
                       "+"
                       "1"
                       ","
                       ")"
                       ","
                       (var "y")
                       "_"
                       (var "r")
                       "+"
                       (var "zoom")
                       "_"
                       (var "y")
                       ","
                       "\u2061"
                       "("
                       (var "m")
                       "+"
                       "1"
                       ","
                       ")"
                       ")")))
     (para "
where "
           (math (var "zoom") "_" (var "x"))
           "
is the value of "
           (code "GL_ZOOM_X")
           " and "
           (math (var "zoom") "_" (var "y"))
           "
is the value of "
           (code "GL_ZOOM_Y")
           ". ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "format")
           " or "
           (var "type")
           " is not one of
            the accepted values. ")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "type")
           " is "
           (code "GL_BITMAP")
           " and "
           (var "format")
           " is not either "
           (code "GL_COLOR_INDEX")
           " or "
           (code "GL_STENCIL_INDEX")
           ". ")
     (para (code "GL_INVALID_VALUE")
           " is generated if either "
           (var "width")
           " or "
           (var "height")
           " is negative. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (var "format")
           " is "
           (code "GL_STENCIL_INDEX")
           "
and there is no stencil buffer. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (var "format")
           " is "
           (code "GL_RED")
           ", "
           (code "GL_GREEN")
           ", "
           (code "GL_BLUE")
           ", "
           (code "GL_ALPHA")
           ", "
           (code "GL_RGB")
           ", "
           (code "GL_RGBA")
           ", "
           (code "GL_BGR")
           ", "
           (code "GL_BGRA")
           ", "
           (code "GL_LUMINANCE")
           ",
            or "
           (code "GL_LUMINANCE_ALPHA")
           ",
            and the GL is in color index mode. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (var "format")
           " is one of "
           (code "GL_UNSIGNED_BYTE_3_3_2")
           ", "
           (code "GL_UNSIGNED_BYTE_2_3_3_REV")
           ", "
           (code "GL_UNSIGNED_SHORT_5_6_5")
           ", or "
           (code "GL_UNSIGNED_SHORT_5_6_5_REV")
           "
and "
           (var "format")
           " is not "
           (code "GL_RGB")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (var "format")
           " is one of "
           (code "GL_UNSIGNED_SHORT_4_4_4_4")
           ", "
           (code "GL_UNSIGNED_SHORT_4_4_4_4_REV")
           ", "
           (code "GL_UNSIGNED_SHORT_5_5_5_1")
           ", "
           (code "GL_UNSIGNED_SHORT_1_5_5_5_REV")
           ", "
           (code "GL_UNSIGNED_INT_8_8_8_8")
           ", "
           (code "GL_UNSIGNED_INT_8_8_8_8_REV")
           ", "
           (code "GL_UNSIGNED_INT_10_10_10_2")
           ", or "
           (code "GL_UNSIGNED_INT_2_10_10_10_REV")
           "
and "
           (var "format")
           " is neither "
           (code "GL_RGBA")
           " nor "
           (code "GL_BGRA")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target and the buffer object's data store is currently mapped. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target and the data would be unpacked from the buffer 
            object such that the memory reads required would exceed the data store size. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target and "
           (var "data")
           " is not evenly divisible 
            into the number of bytes needed to store in memory a datum indicated by "
           (var "type")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glDrawPixels")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glDrawRangeElements
  "glDrawRangeElements"
  (funcsynopsis
    (funcprototype
      (funcdef
        "void "
        (function "glDrawRangeElements"))
      (paramdef "GLenum " (parameter "mode"))
      (paramdef "GLuint " (parameter "start"))
      (paramdef "GLuint " (parameter "end"))
      (paramdef "GLsizei " (parameter "count"))
      (paramdef "GLenum " (parameter "type"))
      (paramdef
        "const GLvoid * "
        (parameter "indices"))))
  '(*fragment*
     (heading "render primitives from array data")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "mode")))
                   (para "
Specifies what kind of primitives to render.
                    Symbolic constants "
                         (code "GL_POINTS")
                         ", "
                         (code "GL_LINE_STRIP")
                         ", "
                         (code "GL_LINE_LOOP")
                         ", "
                         (code "GL_LINES")
                         ", "
                         (code "GL_TRIANGLE_STRIP")
                         ", "
                         (code "GL_TRIANGLE_FAN")
                         ", "
                         (code "GL_TRIANGLES")
                         ", "
                         (code "GL_QUAD_STRIP")
                         ", "
                         (code "GL_QUADS")
                         ",
                    and "
                         (code "GL_POLYGON")
                         " are accepted. "))
            (entry (% (heading (var "start")))
                   (para "
Specifies the minimum array index contained in "
                         (var "indices")
                         ". "))
            (entry (% (heading (var "end")))
                   (para "
Specifies the maximum array index contained in "
                         (var "indices")
                         ". "))
            (entry (% (heading (var "count")))
                   (para "
Specifies the number of elements to be rendered. "))
            (entry (% (heading (var "type")))
                   (para "
Specifies the type of the values in "
                         (var "indices")
                         ". Must be one of "
                         (code "GL_UNSIGNED_BYTE")
                         ", "
                         (code "GL_UNSIGNED_SHORT")
                         ", or "
                         (code "GL_UNSIGNED_INT")
                         ". "))
            (entry (% (heading (var "indices")))
                   (para "
Specifies a pointer to the location where the indices are stored. ")))
     (heading "Description")
     (para (code "glDrawRangeElements")
           " is a restricted form of "
           (code "glDrawElements")
           ". "
           (var "mode")
           ", "
           (var "start")
           ", "
           (var "end")
           ",
            and "
           (var "count")
           " match the corresponding arguments to "
           (code "glDrawElements")
           ", with
            the additional constraint that all values in the arrays "
           (var "count")
           " must lie
            between "
           (var "start")
           " and "
           (var "end")
           ", inclusive. ")
     (para "
Implementations denote recommended maximum amounts of vertex and
            index data,
            which may be queried by calling "
           (code "glGet")
           " with argument "
           (code "GL_MAX_ELEMENTS_VERTICES")
           " and "
           (code "GL_MAX_ELEMENTS_INDICES")
           ".
            If "
           (math (var "end") "-" (var "start") "+" "1")
           "
is greater than the value of "
           (code "GL_MAX_ELEMENTS_VERTICES")
           ", or if "
           (var "count")
           " is greater than the value of "
           (code "GL_MAX_ELEMENTS_INDICES")
           ", then the call may operate at reduced
            performance.  There is no requirement that all vertices in the range "
           (math "[" (var "start") "," (var "end") "]")
           "
be referenced.  However, the implementation may
            partially process unused vertices, reducing performance from what could
            be achieved with an optimal index set. ")
     (para "
When "
           (code "glDrawRangeElements")
           " is called, it uses "
           (var "count")
           " sequential elements from an
            enabled array, starting at "
           (var "start")
           " to construct a sequence of
            geometric primitives. "
           (var "mode")
           " specifies what kind of primitives are
            constructed, and how the array elements construct these primitives. If
            more than one array is enabled, each is used. If "
           (code "GL_VERTEX_ARRAY")
           " is not enabled, no geometric primitives are
            constructed. ")
     (para "
Vertex attributes that are modified by "
           (code "glDrawRangeElements")
           " have an
            unspecified value after "
           (code "glDrawRangeElements")
           " returns. For example, if "
           (code "GL_COLOR_ARRAY")
           " is enabled, the value of the current color is
            undefined after "
           (code "glDrawRangeElements")
           " executes. Attributes that aren't
            modified maintain their previous values. ")
     (heading "Errors")
     (para "
It is an error for indices to lie outside the range "
           (math "[" (var "start") "," (var "end") "]")
           ",
            but implementations may not check for this situation. Such indices
            cause implementation-dependent behavior. ")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "mode")
           " is not an accepted value. ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "count")
           " is negative. ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (math (var "end") "<" (var "start"))
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to an
            enabled array or the element array and the buffer object's data store is currently mapped. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glDrawRangeElements")
           " is executed between
            the execution of "
           (code "glBegin")
           " and the corresponding "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glEdgeFlagPointer
  "glEdgeFlagPointer"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glEdgeFlagPointer"))
      (paramdef "GLsizei " (parameter "stride"))
      (paramdef
        "const GLvoid * "
        (parameter "pointer"))))
  '(*fragment*
     (heading "define an array of edge flags")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "stride")))
                   (para "
Specifies the byte offset between consecutive edge flags.
                    If "
                         (var "stride")
                         " is 0, the edge flags are understood
                    to be tightly packed in the array. The initial value is 0. "))
            (entry (% (heading (var "pointer")))
                   (para "
Specifies a pointer to the first edge flag in the array. The initial
                    value is 0. ")))
     (heading "Description")
     (para (code "glEdgeFlagPointer")
           " specifies the location and data format of an array of boolean edge
            flags to use when rendering. "
           (var "stride")
           " specifies the byte stride from one
            edge flag to the next, allowing vertices and attributes
            to be packed into a single array or stored in separate arrays. ")
     (para "
If a non-zero named buffer object is bound to the "
           (code "GL_ARRAY_BUFFER")
           " target 
            (see "
           (code "glBindBuffer")
           ") while an edge flag array is
            specified, "
           (var "pointer")
           " is treated as a byte offset into the buffer object's data store.
            Also, the buffer object binding ("
           (code "GL_ARRAY_BUFFER_BINDING")
           ") is saved as edge flag vertex array
            client-side state ("
           (code "GL_EDGE_FLAG_ARRAY_BUFFER_BINDING")
           "). ")
     (para "
When an edge flag array is
            specified, "
           (var "stride")
           " and "
           (var "pointer")
           " are saved as client-side
            state, in addition to the current vertex array buffer object binding. ")
     (para "
To enable and disable the edge flag array, call "
           (code "glEnableClientState")
           " and "
           (code "glDisableClientState")
           " with the argument "
           (code "GL_EDGE_FLAG_ARRAY")
           ". If
            enabled, the edge flag array is used
            when "
           (code "glDrawArrays")
           ", "
           (code "glMultiDrawArrays")
           ", "
           (code "glDrawElements")
           ", "
           (code "glMultiDrawElements")
           ", "
           (code "glDrawRangeElements")
           ", or "
           (code "glArrayElement")
           " is called. ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "stride")
           " is negative. ")))

(define-gl-procedure
  glEdgeFlag
  "glEdgeFlag"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glEdgeFlag"))
      (paramdef "GLboolean " (parameter "flag"))))
  '(*fragment*
     (heading
       "flag edges as either boundary or nonboundary")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "flag")))
                   (para "
Specifies the current edge flag value,
                    either "
                         (code "GL_TRUE")
                         " or "
                         (code "GL_FALSE")
                         ". The initial value is "
                         (code "GL_TRUE")
                         ". ")))
     (heading "Description")
     (para "
Each vertex of a polygon,
            separate triangle,
            or separate quadrilateral specified between a "
           (code "glBegin")
           "/"
           (code "glEnd")
           " pair
            is marked as the start of either a boundary or nonboundary edge.
            If the current edge flag is true when the vertex is specified,
            the vertex is marked as the start of a boundary edge.
            Otherwise, the vertex is marked as the start of a nonboundary edge. "
           (code "glEdgeFlag")
           " sets the edge flag bit to "
           (code "GL_TRUE")
           " if "
           (var "flag")
           " is "
           (code "GL_TRUE")
           "
and to "
           (code "GL_FALSE")
           " otherwise. ")
     (para "
The vertices of connected triangles and connected quadrilaterals are always
            marked as boundary,
            regardless of the value of the edge flag. ")
     (para "
Boundary and nonboundary edge flags on vertices are significant only if "
           (code "GL_POLYGON_MODE")
           " is set to "
           (code "GL_POINT")
           " or "
           (code "GL_LINE")
           ".
            See "
           (code "glPolygonMode")
           ". ")))

(define-gl-procedure
  glEnableClientState
  "glEnableClientState"
  (funcsynopsis
    (funcprototype
      (funcdef
        "void "
        (function "glEnableClientState"))
      (paramdef "GLenum " (parameter "cap"))))
  '(*fragment*
     (heading
       "enable or disable client-side capability")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "cap")))
                   (para "
Specifies the capability to enable.
                    Symbolic constants "
                         (code "GL_COLOR_ARRAY")
                         ", "
                         (code "GL_EDGE_FLAG_ARRAY")
                         ", "
                         (code "GL_FOG_COORD_ARRAY")
                         ", "
                         (code "GL_INDEX_ARRAY")
                         ", "
                         (code "GL_NORMAL_ARRAY")
                         ", "
                         (code "GL_SECONDARY_COLOR_ARRAY")
                         ", "
                         (code "GL_TEXTURE_COORD_ARRAY")
                         ", and "
                         (code "GL_VERTEX_ARRAY")
                         "
are accepted. ")))
     (heading "Description")
     (para (code "glEnableClientState")
           " and "
           (code "glDisableClientState")
           "
enable or disable individual client-side capabilities. By default, all
            client-side capabilities are disabled.
            Both "
           (code "glEnableClientState")
           " and "
           (code "glDisableClientState")
           " take a
            single argument, "
           (var "cap")
           ", which can assume one of the following
            values: ")
     (table (% (formatter (asis)))
            (entry (% (heading (code "GL_COLOR_ARRAY")))
                   (para "
If enabled, the color array is enabled for writing and used during
                        rendering when "
                         (code "glArrayElement")
                         ", "
                         (code "glDrawArrays")
                         ", "
                         (code "glDrawElements")
                         ", "
                         (code "glDrawRangeElements")
                         (code "glMultiDrawArrays")
                         ", or "
                         (code "glMultiDrawElements")
                         " is called. See "
                         (code "glColorPointer")
                         ". "))
            (entry (% (heading (code "GL_EDGE_FLAG_ARRAY")))
                   (para "
If enabled, the edge flag array is enabled for writing and used during
                        rendering when "
                         (code "glArrayElement")
                         ", "
                         (code "glDrawArrays")
                         ", "
                         (code "glDrawElements")
                         ", "
                         (code "glDrawRangeElements")
                         (code "glMultiDrawArrays")
                         ", or "
                         (code "glMultiDrawElements")
                         " is called. See "
                         (code "glEdgeFlagPointer")
                         ". "))
            (entry (% (heading (code "GL_FOG_COORD_ARRAY")))
                   (para "
If enabled, the fog coordinate array is enabled for writing and used during
                        rendering when "
                         (code "glArrayElement")
                         ", "
                         (code "glDrawArrays")
                         ", "
                         (code "glDrawElements")
                         ", "
                         (code "glDrawRangeElements")
                         (code "glMultiDrawArrays")
                         ", or "
                         (code "glMultiDrawElements")
                         " is called. See "
                         (code "glFogCoordPointer")
                         ". "))
            (entry (% (heading (code "GL_INDEX_ARRAY")))
                   (para "
If enabled, the index array is enabled for writing and used during
                        rendering when "
                         (code "glArrayElement")
                         ", "
                         (code "glDrawArrays")
                         ", "
                         (code "glDrawElements")
                         ", "
                         (code "glDrawRangeElements")
                         (code "glMultiDrawArrays")
                         ", or "
                         (code "glMultiDrawElements")
                         " is called. See "
                         (code "glIndexPointer")
                         ". "))
            (entry (% (heading (code "GL_NORMAL_ARRAY")))
                   (para "
If enabled, the normal array is enabled for writing and used during
                        rendering when "
                         (code "glArrayElement")
                         ", "
                         (code "glDrawArrays")
                         ", "
                         (code "glDrawElements")
                         ", "
                         (code "glDrawRangeElements")
                         (code "glMultiDrawArrays")
                         ", or "
                         (code "glMultiDrawElements")
                         " is called. See "
                         (code "glNormalPointer")
                         ". "))
            (entry (% (heading (code "GL_SECONDARY_COLOR_ARRAY")))
                   (para "
If enabled, the secondary color array is enabled for writing and used
                        during rendering when "
                         (code "glArrayElement")
                         ", "
                         (code "glDrawArrays")
                         ", "
                         (code "glDrawElements")
                         ", "
                         (code "glDrawRangeElements")
                         (code "glMultiDrawArrays")
                         ", or "
                         (code "glMultiDrawElements")
                         " is called. See "
                         (code "glColorPointer")
                         ". "))
            (entry (% (heading (code "GL_TEXTURE_COORD_ARRAY")))
                   (para "
If enabled, the texture coordinate array is enabled for writing and used
                        during rendering when "
                         (code "glArrayElement")
                         ", "
                         (code "glDrawArrays")
                         ", "
                         (code "glDrawElements")
                         ", "
                         (code "glDrawRangeElements")
                         (code "glMultiDrawArrays")
                         ", or "
                         (code "glMultiDrawElements")
                         " is called. See "
                         (code "glTexCoordPointer")
                         ". "))
            (entry (% (heading (code "GL_VERTEX_ARRAY")))
                   (para "
If enabled, the vertex array is enabled for writing and used during
                        rendering when "
                         (code "glArrayElement")
                         ", "
                         (code "glDrawArrays")
                         ", "
                         (code "glDrawElements")
                         ", "
                         (code "glDrawRangeElements")
                         (code "glMultiDrawArrays")
                         ", or "
                         (code "glMultiDrawElements")
                         " is called.  See "
                         (code "glVertexPointer")
                         ". ")))
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "cap")
           " is not an accepted value. ")
     (para (code "glEnableClientState")
           " is not allowed between the execution of "
           (code "glBegin")
           " and the
            corresponding "
           (code "glEnd")
           ", but an error may or may not be generated. If
            no error is generated, the behavior is undefined. ")))

(define-gl-procedure
  glEnableVertexAttribArray
  "glEnableVertexAttribArray"
  (funcsynopsis
    (funcprototype
      (funcdef
        "void "
        (function "glEnableVertexAttribArray"))
      (paramdef "GLuint " (parameter "index")))
    (funcprototype
      (funcdef
        "void "
        (function "glDisableVertexAttribArray"))
      (paramdef "GLuint " (parameter "index"))))
  '(*fragment*
     (heading
       "Enable or disable a generic vertex attribute array")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "index")))
                   (para "Specifies the index of the generic vertex
\t\t    attribute to be enabled or disabled.")))
     (heading "Description")
     (para (code "glEnableVertexAttribArray")
           " enables the
\tgeneric vertex attribute array specified by\t"
           (var "index")
           ".\t"
           (code "glDisableVertexAttribArray")
           " disables the
\tgeneric vertex attribute array specified by\t"
           (var "index")
           ". By default, all client-side
\tcapabilities are disabled, including all generic vertex
\tattribute arrays. If enabled, the values in the generic vertex
\tattribute array will be accessed and used for rendering when
\tcalls are made to vertex array commands such as\t"
           (code "glDrawArrays")
           ",\t"
           (code "glDrawElements")
           ",\t"
           (code "glDrawRangeElements")
           ",\t"
           (code "glArrayElement")
           ",\t"
           (code "glMultiDrawElements")
           ",
\tor\t"
           (code "glMultiDrawArrays")
           ".")
     (heading "Errors")
     (para (code "GL_INVALID_VALUE")
           " is generated if\t"
           (var "index")
           " is greater than or equal to\t"
           (code "GL_MAX_VERTEX_ATTRIBS")
           ".")
     (para (code "GL_INVALID_OPERATION")
           " is generated if either\t"
           (code "glEnableVertexAttribArray ")
           " or\t"
           (code "glDisableVertexAttribArray ")
           " is executed
\tbetween the execution of\t"
           (code "glBegin")
           "
and the corresponding execution of\t"
           (code "glEnd")
           ".")))

(define-gl-procedure
  glEnable
  "glEnable"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glEnable"))
      (paramdef "GLenum " (parameter "cap"))))
  '(*fragment*
     (heading
       "enable or disable server-side GL capabilities")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "cap")))
                   (para "
Specifies a symbolic constant indicating a GL capability. ")))
     (heading "Description")
     (para (code "glEnable")
           " and "
           (code "glDisable")
           " enable and disable various capabilities.
            Use "
           (code "glIsEnabled")
           " or "
           (code "glGet")
           " to determine the current setting
            of any capability. The initial value for each capability with the
            exception of "
           (code "GL_DITHER")
           " and "
           (code "GL_MULTISAMPLE")
           " is "
           (code "GL_FALSE")
           ". The initial value for "
           (code "GL_DITHER")
           " and "
           (code "GL_MULTISAMPLE")
           " is "
           (code "GL_TRUE")
           ". ")
     (para "
Both "
           (code "glEnable")
           " and "
           (code "glDisable")
           " take a single argument, "
           (var "cap")
           ",
            which can assume one of the following values: ")
     (table (% (formatter (asis)))
            (entry (% (heading (code "GL_ALPHA_TEST")))
                   (para)
                   (para "
If enabled,
                        do alpha testing. See "
                         (code "glAlphaFunc")
                         ". "))
            (entry (% (heading (code "GL_AUTO_NORMAL")))
                   (para)
                   (para "
If enabled,
                        generate normal vectors when either "
                         (code "GL_MAP2_VERTEX_3")
                         " or "
                         (code "GL_MAP2_VERTEX_4")
                         " is used to generate vertices.
                        See "
                         (code "glMap2")
                         ". "))
            (entry (% (heading (code "GL_BLEND")))
                   (para)
                   (para "
If enabled,
                        blend the computed fragment color values with the values in the color
                        buffers. See "
                         (code "glBlendFunc")
                         ". "))
            (entry (% (heading (code "GL_CLIP_PLANE") (var "i")))
                   (para)
                   (para "
If enabled,
                        clip geometry against user-defined clipping plane "
                         (var "i")
                         ".
                        See "
                         (code "glClipPlane")
                         ". "))
            (entry (% (heading (code "GL_COLOR_LOGIC_OP")))
                   (para)
                   (para "
If enabled,
                        apply the currently selected logical operation to the computed fragment
                        color and color buffer values. See "
                         (code "glLogicOp")
                         ". "))
            (entry (% (heading (code "GL_COLOR_MATERIAL")))
                   (para)
                   (para "
If enabled,
                        have one or more material parameters track the current color.
                        See "
                         (code "glColorMaterial")
                         ". "))
            (entry (% (heading (code "GL_COLOR_SUM")))
                   (para)
                   (para "
If enabled and no fragment shader is active, 
                        add the secondary color value to the computed fragment color.
                        See "
                         (code "glSecondaryColor")
                         ". "))
            (entry (% (heading (code "GL_COLOR_TABLE")))
                   (para)
                   (para "
If enabled,
                        perform a color table lookup on the incoming RGBA color values.
                        See "
                         (code "glColorTable")
                         ". "))
            (entry (% (heading (code "GL_CONVOLUTION_1D")))
                   (para)
                   (para "
If enabled,
                        perform a 1D convolution operation on incoming RGBA color values.
                        See "
                         (code "glConvolutionFilter1D")
                         ". "))
            (entry (% (heading (code "GL_CONVOLUTION_2D")))
                   (para)
                   (para "
If enabled,
                        perform a 2D convolution operation on incoming RGBA color values.
                        See "
                         (code "glConvolutionFilter2D")
                         ". "))
            (entry (% (heading (code "GL_CULL_FACE")))
                   (para)
                   (para "
If enabled,
                        cull polygons based on their winding in window coordinates.
                        See "
                         (code "glCullFace")
                         ". "))
            (entry (% (heading (code "GL_DEPTH_TEST")))
                   (para)
                   (para "
If enabled,
                        do depth comparisons and update the depth buffer. Note that even if
                        the depth buffer exists and the depth mask is non-zero, the
                        depth buffer is not updated if the depth test is disabled. See "
                         (code "glDepthFunc")
                         " and "
                         (code "glDepthRange")
                         ". "))
            (entry (% (heading (code "GL_DITHER")))
                   (para)
                   (para "
If enabled,
                        dither color components or indices before they are written to the
                        color buffer. "))
            (entry (% (heading (code "GL_FOG")))
                   (para)
                   (para "
If enabled and no fragment shader is active,
                        blend a fog color into the post-texturing color.
                        See "
                         (code "glFog")
                         ". "))
            (entry (% (heading (code "GL_HISTOGRAM")))
                   (para)
                   (para "
If enabled,
                        histogram incoming RGBA color values.
                        See "
                         (code "glHistogram")
                         ". "))
            (entry (% (heading (code "GL_INDEX_LOGIC_OP")))
                   (para)
                   (para "
If enabled,
                        apply the currently selected logical operation to the incoming index and color
                        buffer indices.
                        See "
                         (code "glLogicOp")
                         ". "))
            (entry (% (heading (code "GL_LIGHT") (var "i")))
                   (para)
                   (para "
If enabled,
                        include light "
                         (var "i")
                         " in the evaluation of the lighting
                        equation. See "
                         (code "glLightModel")
                         " and "
                         (code "glLight")
                         ". "))
            (entry (% (heading (code "GL_LIGHTING")))
                   (para)
                   (para "
If enabled and no vertex shader is active,
                        use the current lighting parameters to compute the vertex color or index.
                        Otherwise, simply associate the current color or index with each
                        vertex. See "
                         (code "glMaterial")
                         ", "
                         (code "glLightModel")
                         ", and "
                         (code "glLight")
                         ". "))
            (entry (% (heading (code "GL_LINE_SMOOTH")))
                   (para)
                   (para "
If enabled,
                        draw lines with correct filtering.
                        Otherwise,
                        draw aliased lines.
                        See "
                         (code "glLineWidth")
                         ". "))
            (entry (% (heading (code "GL_LINE_STIPPLE")))
                   (para)
                   (para "
If enabled,
                        use the current line stipple pattern when drawing lines. See "
                         (code "glLineStipple")
                         ". "))
            (entry (% (heading (code "GL_MAP1_COLOR_4")))
                   (para)
                   (para "
If enabled,
                        calls to "
                         (code "glEvalCoord1")
                         ", "
                         (code "glEvalMesh1")
                         ", and "
                         (code "glEvalPoint1")
                         " generate RGBA values.
                        See "
                         (code "glMap1")
                         ". "))
            (entry (% (heading (code "GL_MAP1_INDEX")))
                   (para)
                   (para "
If enabled,
                        calls to "
                         (code "glEvalCoord1")
                         ", "
                         (code "glEvalMesh1")
                         ", and "
                         (code "glEvalPoint1")
                         " generate color indices.
                        See "
                         (code "glMap1")
                         ". "))
            (entry (% (heading (code "GL_MAP1_NORMAL")))
                   (para)
                   (para "
If enabled,
                        calls to "
                         (code "glEvalCoord1")
                         ", "
                         (code "glEvalMesh1")
                         ", and "
                         (code "glEvalPoint1")
                         " generate normals.
                        See "
                         (code "glMap1")
                         ". "))
            (entry (% (heading (code "GL_MAP1_TEXTURE_COORD_1")))
                   (para)
                   (para "
If enabled,
                        calls to "
                         (code "glEvalCoord1")
                         ", "
                         (code "glEvalMesh1")
                         ", and "
                         (code "glEvalPoint1")
                         " generate "
                         (var "s")
                         "
texture coordinates.
                        See "
                         (code "glMap1")
                         ". "))
            (entry (% (heading (code "GL_MAP1_TEXTURE_COORD_2")))
                   (para)
                   (para "
If enabled,
                        calls to "
                         (code "glEvalCoord1")
                         ", "
                         (code "glEvalMesh1")
                         ", and "
                         (code "glEvalPoint1")
                         " generate "
                         (var "s")
                         " and "
                         (var "t")
                         " texture coordinates.
                        See "
                         (code "glMap1")
                         ". "))
            (entry (% (heading (code "GL_MAP1_TEXTURE_COORD_3")))
                   (para)
                   (para "
If enabled,
                        calls to "
                         (code "glEvalCoord1")
                         ", "
                         (code "glEvalMesh1")
                         ", and "
                         (code "glEvalPoint1")
                         " generate "
                         (var "s")
                         ", "
                         (var "t")
                         ", and "
                         (var "r")
                         " texture coordinates.
                        See "
                         (code "glMap1")
                         ". "))
            (entry (% (heading (code "GL_MAP1_TEXTURE_COORD_4")))
                   (para)
                   (para "
If enabled,
                        calls to "
                         (code "glEvalCoord1")
                         ", "
                         (code "glEvalMesh1")
                         ", and "
                         (code "glEvalPoint1")
                         " generate "
                         (var "s")
                         ", "
                         (var "t")
                         ", "
                         (var "r")
                         ", and "
                         (var "q")
                         " texture coordinates.
                        See "
                         (code "glMap1")
                         ". "))
            (entry (% (heading (code "GL_MAP1_VERTEX_3")))
                   (para)
                   (para "
If enabled,
                        calls to "
                         (code "glEvalCoord1")
                         ", "
                         (code "glEvalMesh1")
                         ", and "
                         (code "glEvalPoint1")
                         " generate "
                         (var "x")
                         ", "
                         (var "y")
                         ", and "
                         (var "z")
                         " vertex coordinates.
                        See "
                         (code "glMap1")
                         ". "))
            (entry (% (heading (code "GL_MAP1_VERTEX_4")))
                   (para)
                   (para "
If enabled,
                        calls to "
                         (code "glEvalCoord1")
                         ", "
                         (code "glEvalMesh1")
                         ", and "
                         (code "glEvalPoint1")
                         " generate
                        homogeneous "
                         (var "x")
                         ", "
                         (var "y")
                         ", "
                         (var "z")
                         ", and "
                         (var "w")
                         " vertex coordinates.
                        See "
                         (code "glMap1")
                         ". "))
            (entry (% (heading (code "GL_MAP2_COLOR_4")))
                   (para)
                   (para "
If enabled,
                        calls to "
                         (code "glEvalCoord2")
                         ", "
                         (code "glEvalMesh2")
                         ", and "
                         (code "glEvalPoint2")
                         " generate RGBA values.
                        See "
                         (code "glMap2")
                         ". "))
            (entry (% (heading (code "GL_MAP2_INDEX")))
                   (para)
                   (para "
If enabled,
                        calls to "
                         (code "glEvalCoord2")
                         ", "
                         (code "glEvalMesh2")
                         ", and "
                         (code "glEvalPoint2")
                         " generate color indices.
                        See "
                         (code "glMap2")
                         ". "))
            (entry (% (heading (code "GL_MAP2_NORMAL")))
                   (para)
                   (para "
If enabled,
                        calls to "
                         (code "glEvalCoord2")
                         ", "
                         (code "glEvalMesh2")
                         ", and "
                         (code "glEvalPoint2")
                         " generate normals.
                        See "
                         (code "glMap2")
                         ". "))
            (entry (% (heading (code "GL_MAP2_TEXTURE_COORD_1")))
                   (para)
                   (para "
If enabled,
                        calls to "
                         (code "glEvalCoord2")
                         ", "
                         (code "glEvalMesh2")
                         ", and "
                         (code "glEvalPoint2")
                         " generate "
                         (var "s")
                         "
texture coordinates.
                        See "
                         (code "glMap2")
                         ". "))
            (entry (% (heading (code "GL_MAP2_TEXTURE_COORD_2")))
                   (para)
                   (para "
If enabled,
                        calls to "
                         (code "glEvalCoord2")
                         ", "
                         (code "glEvalMesh2")
                         ", and "
                         (code "glEvalPoint2")
                         " generate "
                         (var "s")
                         " and "
                         (var "t")
                         " texture coordinates.
                        See "
                         (code "glMap2")
                         ". "))
            (entry (% (heading (code "GL_MAP2_TEXTURE_COORD_3")))
                   (para)
                   (para "
If enabled,
                        calls to "
                         (code "glEvalCoord2")
                         ", "
                         (code "glEvalMesh2")
                         ", and "
                         (code "glEvalPoint2")
                         " generate "
                         (var "s")
                         ", "
                         (var "t")
                         ", and "
                         (var "r")
                         " texture coordinates.
                        See "
                         (code "glMap2")
                         ". "))
            (entry (% (heading (code "GL_MAP2_TEXTURE_COORD_4")))
                   (para)
                   (para "
If enabled,
                        calls to "
                         (code "glEvalCoord2")
                         ", "
                         (code "glEvalMesh2")
                         ", and "
                         (code "glEvalPoint2")
                         " generate "
                         (var "s")
                         ", "
                         (var "t")
                         ", "
                         (var "r")
                         ", and "
                         (var "q")
                         " texture coordinates.
                        See "
                         (code "glMap2")
                         ". "))
            (entry (% (heading (code "GL_MAP2_VERTEX_3")))
                   (para)
                   (para "
If enabled,
                        calls to "
                         (code "glEvalCoord2")
                         ", "
                         (code "glEvalMesh2")
                         ", and "
                         (code "glEvalPoint2")
                         " generate "
                         (var "x")
                         ", "
                         (var "y")
                         ", and "
                         (var "z")
                         " vertex coordinates.
                        See "
                         (code "glMap2")
                         ". "))
            (entry (% (heading (code "GL_MAP2_VERTEX_4")))
                   (para)
                   (para "
If enabled,
                        calls to "
                         (code "glEvalCoord2")
                         ", "
                         (code "glEvalMesh2")
                         ", and "
                         (code "glEvalPoint2")
                         " generate
                        homogeneous "
                         (var "x")
                         ", "
                         (var "y")
                         ", "
                         (var "z")
                         ", and "
                         (var "w")
                         " vertex coordinates.
                        See "
                         (code "glMap2")
                         ". "))
            (entry (% (heading (code "GL_MINMAX")))
                   (para)
                   (para "
If enabled,
                        compute the minimum and maximum values of incoming RGBA color values.
                        See "
                         (code "glMinmax")
                         ". "))
            (entry (% (heading (code "GL_MULTISAMPLE")))
                   (para)
                   (para "
If enabled,
                        use multiple fragment samples in computing the final color of a pixel.
                        See "
                         (code "glSampleCoverage")
                         ". "))
            (entry (% (heading (code "GL_NORMALIZE")))
                   (para)
                   (para "
If enabled and no vertex shader is active,
                        normal vectors are normalized to unit length
                        after transformation and before lighting.  This method is generally
                        less efficient than "
                         (code "GL_RESCALE_NORMAL")
                         ". See "
                         (code "glNormal")
                         " and "
                         (code "glNormalPointer")
                         ". "))
            (entry (% (heading (code "GL_POINT_SMOOTH")))
                   (para)
                   (para "
If enabled,
                        draw points with proper filtering.
                        Otherwise,
                        draw aliased points.
                        See "
                         (code "glPointSize")
                         ". "))
            (entry (% (heading (code "GL_POINT_SPRITE")))
                   (para)
                   (para "
If enabled,
                        calculate texture coordinates for points based on texture
                        environment and point parameter settings.  Otherwise texture coordinates
                        are constant across points. "))
            (entry (% (heading (code "GL_POLYGON_OFFSET_FILL")))
                   (para)
                   (para "
If enabled, and if the polygon is rendered in "
                         (code "GL_FILL")
                         " mode, an offset is added to depth values of a polygon's
                        fragments before the depth comparison is performed.
                        See "
                         (code "glPolygonOffset")
                         ". "))
            (entry (% (heading (code "GL_POLYGON_OFFSET_LINE")))
                   (para)
                   (para "
If enabled, and if the polygon is rendered in "
                         (code "GL_LINE")
                         " mode, an offset is added to depth values of a polygon's
                        fragments before the depth comparison is performed.
                        See "
                         (code "glPolygonOffset")
                         ". "))
            (entry (% (heading (code "GL_POLYGON_OFFSET_POINT")))
                   (para)
                   (para "
If enabled, an offset is added to depth values of a polygon's fragments
                        before the depth comparison is performed, if the polygon is rendered in "
                         (code "GL_POINT")
                         " mode. See "
                         (code "glPolygonOffset")
                         ". "))
            (entry (% (heading (code "GL_POLYGON_SMOOTH")))
                   (para)
                   (para "
If enabled, draw polygons with proper filtering.
                        Otherwise, draw aliased polygons. For correct antialiased polygons,
                        an alpha buffer is needed and the polygons must be sorted front to
                        back. "))
            (entry (% (heading (code "GL_POLYGON_STIPPLE")))
                   (para)
                   (para "
If enabled,
                        use the current polygon stipple pattern when rendering
                        polygons. See "
                         (code "glPolygonStipple")
                         ". "))
            (entry (% (heading
                        (code "GL_POST_COLOR_MATRIX_COLOR_TABLE")))
                   (para)
                   (para "
If enabled,
                        perform a color table lookup on RGBA color values after color matrix
                        transformation.
                        See "
                         (code "glColorTable")
                         ". "))
            (entry (% (heading
                        (code "GL_POST_CONVOLUTION_COLOR_TABLE")))
                   (para)
                   (para "
If enabled,
                        perform a color table lookup on RGBA color values after convolution.
                        See "
                         (code "glColorTable")
                         ". "))
            (entry (% (heading (code "GL_RESCALE_NORMAL")))
                   (para)
                   (para "
If enabled and no vertex shader is active, 
                        normal vectors are scaled after transformation and before 
                        lighting by a factor computed from the modelview matrix.  If the
                        modelview matrix scales space uniformly, this has the effect of
                        restoring the transformed normal to unit length.  This method is generally
                        more efficient than "
                         (code "GL_NORMALIZE")
                         ". See "
                         (code "glNormal")
                         " and "
                         (code "glNormalPointer")
                         ". "))
            (entry (% (heading (code "GL_SAMPLE_ALPHA_TO_COVERAGE")))
                   (para)
                   (para "
If enabled,
                        compute a temporary coverage value where each bit is determined by the
                        alpha value at the corresponding sample location.  The temporary coverage
                        value is then ANDed with the fragment coverage value. "))
            (entry (% (heading (code "GL_SAMPLE_ALPHA_TO_ONE")))
                   (para)
                   (para "
If enabled,
                        each sample alpha value is replaced by the maximum representable alpha value. "))
            (entry (% (heading (code "GL_SAMPLE_COVERAGE")))
                   (para)
                   (para "
If enabled,
                        the fragment's coverage is ANDed with the temporary coverage value.  If "
                         (code "GL_SAMPLE_COVERAGE_INVERT")
                         " is set to "
                         (code "GL_TRUE")
                         ", invert the coverage
                        value.
                        See "
                         (code "glSampleCoverage")
                         ". "))
            (entry (% (heading (code "GL_SEPARABLE_2D")))
                   (para)
                   (para "
If enabled, perform a two-dimensional convolution operation using a separable
                        convolution filter on incoming RGBA color values.
                        See "
                         (code "glSeparableFilter2D")
                         ". "))
            (entry (% (heading (code "GL_SCISSOR_TEST")))
                   (para)
                   (para "
If enabled,
                        discard fragments that are outside the scissor rectangle.
                        See "
                         (code "glScissor")
                         ". "))
            (entry (% (heading (code "GL_STENCIL_TEST")))
                   (para)
                   (para "
If enabled,
                        do stencil testing and update the stencil buffer.
                        See "
                         (code "glStencilFunc")
                         " and "
                         (code "glStencilOp")
                         ". "))
            (entry (% (heading (code "GL_TEXTURE_1D")))
                   (para)
                   (para "
If enabled and no fragment shader is active, 
                        one-dimensional texturing is performed
                        (unless two- or three-dimensional or cube-mapped texturing is also enabled).
                        See "
                         (code "glTexImage1D")
                         ". "))
            (entry (% (heading (code "GL_TEXTURE_2D")))
                   (para)
                   (para "
If enabled and no fragment shader is active, 
                        two-dimensional texturing is performed
                        (unless three-dimensional or cube-mapped texturing is also enabled).
                        See "
                         (code "glTexImage2D")
                         ". "))
            (entry (% (heading (code "GL_TEXTURE_3D")))
                   (para)
                   (para "
If enabled and no fragment shader is active, 
                        three-dimensional texturing is performed
                        (unless cube-mapped texturing is also enabled).
                        See "
                         (code "glTexImage3D")
                         ". "))
            (entry (% (heading (code "GL_TEXTURE_CUBE_MAP")))
                   (para)
                   (para "
If enabled and no fragment shader is active, 
                        cube-mapped texturing is performed.
                        See "
                         (code "glTexImage2D")
                         ". "))
            (entry (% (heading (code "GL_TEXTURE_GEN_Q")))
                   (para)
                   (para "
If enabled and no vertex shader is active,
                        the "
                         (var "q")
                         " texture coordinate is computed using
                        the texture generation function defined with "
                         (code "glTexGen")
                         ".
                        Otherwise, the current "
                         (var "q")
                         " texture coordinate is used.
                        See "
                         (code "glTexGen")
                         ". "))
            (entry (% (heading (code "GL_TEXTURE_GEN_R")))
                   (para)
                   (para "
If enabled and no vertex shader is active,
                        the "
                         (var "r")
                         " texture coordinate is computed using
                        the texture generation function defined with "
                         (code "glTexGen")
                         ".
                        Otherwise, the current "
                         (var "r")
                         " texture coordinate is used.
                        See "
                         (code "glTexGen")
                         ". "))
            (entry (% (heading (code "GL_TEXTURE_GEN_S")))
                   (para)
                   (para "
If enabled and no vertex shader is active,
                        the "
                         (var "s")
                         " texture coordinate is computed using
                        the texture generation function defined with "
                         (code "glTexGen")
                         ".
                        Otherwise, the current "
                         (var "s")
                         " texture coordinate is used.
                        See "
                         (code "glTexGen")
                         ". "))
            (entry (% (heading (code "GL_TEXTURE_GEN_T")))
                   (para)
                   (para "
If enabled and no vertex shader is active,
                        the "
                         (var "t")
                         " texture coordinate is computed using
                        the texture generation function defined with "
                         (code "glTexGen")
                         ".
                        Otherwise, the current "
                         (var "t")
                         " texture coordinate is used.
                        See "
                         (code "glTexGen")
                         ". "))
            (entry (% (heading (code "GL_VERTEX_PROGRAM_POINT_SIZE")))
                   (para)
                   (para "
If enabled
                        and a vertex shader is active, then the derived point size is taken from the (potentially clipped) shader builtin "
                         (code "gl_PointSize")
                         " and clamped to the implementation-dependent point size range. "))
            (entry (% (heading (code "GL_VERTEX_PROGRAM_TWO_SIDE")))
                   (para)
                   (para "
If enabled
                        and a vertex shader is active, it specifies that the GL will choose between front and back colors based on the
                        polygon's face direction of which the vertex being shaded is a part.  It has no effect on points or lines. ")))
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "cap")
           " is not one of the values
            listed previously. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glEnable")
           " or "
           (code "glDisable")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glEvalCoord
  "glEvalCoord"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glEvalCoord1f"))
      (paramdef "GLfloat " (parameter "u"))))
  '(*fragment*
     (heading
       "evaluate enabled one- and two-dimensional maps")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "u")))
                   (para "
Specifies a value that is the domain coordinate "
                         (math (var "u"))
                         "
to the basis function
                    defined in a previous "
                         (code "glMap1")
                         " or "
                         (code "glMap2")
                         " command. "))
            (entry (% (heading (var "v")))
                   (para "
Specifies a value that is the domain coordinate "
                         (math (var "v"))
                         "
to the basis function
                    defined in a previous "
                         (code "glMap2")
                         " command.
                    This argument is not present in a "
                         (code "glEvalCoord1")
                         " command. ")))
     (heading "Description")
     (para (code "glEvalCoord1")
           " evaluates enabled one-dimensional maps at argument "
           (var "u")
           ". "
           (code "glEvalCoord2")
           " does the same for two-dimensional maps using
            two domain values, "
           (var "u")
           " and "
           (var "v")
           ".
            To define a map, call "
           (code "glMap1")
           " and "
           (code "glMap2")
           "; to enable and
            disable it, call "
           (code "glEnable")
           " and "
           (code "glDisable")
           ". ")
     (para "
When one of the "
           (code "glEvalCoord")
           " commands is issued,
            all currently enabled maps of the indicated dimension are evaluated.
            Then,
            for each enabled map,
            it is as if the corresponding GL command had been issued with the
            computed value.
            That is,
            if "
           (code "GL_MAP1_INDEX")
           " or "
           (code "GL_MAP2_INDEX")
           " is enabled,
            a "
           (code "glIndex")
           " command is simulated.
            If "
           (code "GL_MAP1_COLOR_4")
           " or "
           (code "GL_MAP2_COLOR_4")
           " is enabled,
            a "
           (code "glColor")
           " command is simulated.
            If "
           (code "GL_MAP1_NORMAL")
           " or "
           (code "GL_MAP2_NORMAL")
           " is enabled,
            a normal vector is produced,
            and if any of "
           (code "GL_MAP1_TEXTURE_COORD_1")
           ", "
           (code "GL_MAP1_TEXTURE_COORD_2")
           ", "
           (code "GL_MAP1_TEXTURE_COORD_3")
           ", "
           (code "GL_MAP1_TEXTURE_COORD_4")
           ", "
           (code "GL_MAP2_TEXTURE_COORD_1")
           ", "
           (code "GL_MAP2_TEXTURE_COORD_2")
           ", "
           (code "GL_MAP2_TEXTURE_COORD_3")
           ", or "
           (code "GL_MAP2_TEXTURE_COORD_4")
           " is enabled, then an appropriate "
           (code "glTexCoord")
           " command is simulated. ")
     (para "
For color,
            color index,
            normal,
            and texture coordinates the GL uses evaluated values instead of current values for those evaluations
            that are enabled,
            and current values otherwise,
            However,
            the evaluated values do not update the current values.
            Thus, if "
           (code "glVertex")
           " commands are interspersed with "
           (code "glEvalCoord")
           "
commands, the color,
            normal,
            and texture coordinates associated with the "
           (code "glVertex")
           " commands are not
            affected by the values generated by the "
           (code "glEvalCoord")
           " commands,
            but only by the most recent "
           (code "glColor")
           ", "
           (code "glIndex")
           ", "
           (code "glNormal")
           ", and "
           (code "glTexCoord")
           " commands. ")
     (para "
No commands are issued for maps that are not enabled.
            If more than one texture evaluation is enabled for a particular dimension
            (for example, "
           (code "GL_MAP2_TEXTURE_COORD_1")
           " and "
           (code "GL_MAP2_TEXTURE_COORD_2")
           "),
            then only the evaluation of the map that produces the larger
            number of coordinates
            (in this case, "
           (code "GL_MAP2_TEXTURE_COORD_2")
           ")
            is carried out. "
           (code "GL_MAP1_VERTEX_4")
           " overrides "
           (code "GL_MAP1_VERTEX_3")
           ",
            and "
           (code "GL_MAP2_VERTEX_4")
           " overrides "
           (code "GL_MAP2_VERTEX_3")
           ",
            in the same manner.
            If neither a three- nor a four-component vertex map is enabled for the
            specified dimension,
            the "
           (code "glEvalCoord")
           " command is ignored. ")
     (para "
If you have enabled automatic normal generation,
            by calling "
           (code "glEnable")
           " with argument "
           (code "GL_AUTO_NORMAL")
           ", "
           (code "glEvalCoord2")
           " generates surface normals analytically,
            regardless of the contents or enabling of the "
           (code "GL_MAP2_NORMAL")
           " map.
            Let ")
     (para (math (code "m")
                 "="
                 "∂"
                 (code "p")
                 ","
                 "/"
                 "∂"
                 (var "u")
                 ","
                 ","
                 "×"
                 "∂"
                 (code "p")
                 ","
                 "/"
                 "∂"
                 (var "v")
                 ","
                 ","))
     (para "
Then the generated normal "
           (math (code "n"))
           "
is "
           (math (code "n")
                 "="
                 (code "m")
                 "/"
                 "∥"
                 (code "m")
                 ","
                 "∥"
                 ","))
     (para "
If automatic normal generation is disabled,
            the corresponding normal map "
           (code "GL_MAP2_NORMAL")
           ",
            if enabled,
            is used to produce a normal.
            If neither automatic normal generation nor a normal map is enabled,
            no normal is generated for "
           (code "glEvalCoord2")
           " commands. ")))

(define-gl-procedure
  glEvalMesh
  "glEvalMesh"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glEvalMesh1"))
      (paramdef "GLenum " (parameter "mode"))
      (paramdef "GLint " (parameter "i1"))
      (paramdef "GLint " (parameter "i2"))))
  '(*fragment*
     (heading
       "compute a one- or two-dimensional grid of points or lines")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "mode")))
                   (para "
In "
                         (code "glEvalMesh1")
                         ", specifies whether to compute a one-dimensional mesh of points or lines.
                    Symbolic constants "
                         (code "GL_POINT")
                         " and "
                         (code "GL_LINE")
                         " are accepted. "))
            (entry (% (heading (var "i1")))
                   (itemx (var "i2"))
                   (para "
Specify the first and last integer values for grid domain variable "
                         (math (var "i"))
                         ". ")))
     (heading "Description")
     (para (code "glMapGrid")
           " and "
           (code "glEvalMesh")
           " are used in tandem to efficiently
            generate and evaluate a series of evenly-spaced map domain values. "
           (code "glEvalMesh")
           " steps through the integer domain of a one- or two-dimensional grid,
            whose range is the domain of the evaluation maps specified by "
           (code "glMap1")
           " and "
           (code "glMap2")
           ". "
           (var "mode")
           " determines whether the resulting vertices are connected as
            points,
            lines,
            or filled polygons. ")
     (para "
In the one-dimensional case, "
           (code "glEvalMesh1")
           ",
            the mesh is generated as if the following code fragment were executed: ")
     (para "
where ")
     (example
       "
glBegin( "
       (var "type")
       " );
for ( i = "
       (var "i1")
       "; i <= "
       (var "i2")
       "; i += 1 )
   glEvalCoord1( "
       (math "i"
             "·"
             "Δ"
             (var "u")
             "+"
             (var "u")
             "_"
             "1")
       " );
glEnd(); ")
     (para (math "Δ"
                 (var "u")
                 "="
                 "("
                 (var "u")
                 "_"
                 "2"
                 "-"
                 (var "u")
                 "_"
                 "1"
                 ","
                 ")"
                 "/"
                 (var "n")))
     (para "
and "
           (math (var "n"))
           ", "
           (math (var "u") "_" "1")
           ",
            and "
           (math (var "u") "_" "2")
           "
are the arguments to the most recent "
           (code "glMapGrid1")
           " command. "
           (var "type")
           " is "
           (code "GL_POINTS")
           " if "
           (var "mode")
           " is "
           (code "GL_POINT")
           ",
            or "
           (code "GL_LINES")
           " if "
           (var "mode")
           " is "
           (code "GL_LINE")
           ". ")
     (para "
The one absolute numeric requirement is that if "
           (math (var "i") "=" (var "n"))
           ",
            then the
            value computed from "
           (math (var "i")
                 "·"
                 "Δ"
                 (var "u")
                 "+"
                 (var "u")
                 "_"
                 "1")
           "
is exactly "
           (math (var "u") "_" "2")
           ". ")
     (para "
In the two-dimensional case, "
           (code "glEvalMesh2")
           ", let
            .cp "
           (math "Δ"
                 (var "u")
                 "="
                 "("
                 (var "u")
                 "_"
                 "2"
                 "-"
                 (var "u")
                 "_"
                 "1"
                 ","
                 ")"
                 "/"
                 (var "n")))
     (para (math "Δ"
                 (var "v")
                 "="
                 "("
                 (var "v")
                 "_"
                 "2"
                 "-"
                 (var "v")
                 "_"
                 "1"
                 ","
                 ")"
                 "/"
                 (var "m")))
     (para "
where "
           (math (var "n"))
           ", "
           (math (var "u") "_" "1")
           ", "
           (math (var "u") "_" "2")
           ", "
           (math (var "m"))
           ", "
           (math (var "v") "_" "1")
           ",
            and "
           (math (var "v") "_" "2")
           "
are the
            arguments to the most recent "
           (code "glMapGrid2")
           " command.  Then, if "
           (var "mode")
           " is "
           (code "GL_FILL")
           ", the "
           (code "glEvalMesh2")
           " command is equivalent
            to: ")
     (para)
     (example
       "
for ( j = "
       (var "j1")
       "; j < "
       (var "j2")
       "; j += 1 ) {
   glBegin( GL_QUAD_STRIP );
   for ( i = "
       (var "i1")
       "; i <= "
       (var "i2")
       "; i += 1 ) {
      glEvalCoord2( "
       (math "i"
             "·"
             "Δ"
             (var "u")
             "+"
             (var "u")
             "_"
             "1"
             ","
             "j"
             "·"
             "Δ"
             (var "v")
             "+"
             (var "v")
             "_"
             "1")
       " );
      glEvalCoord2( "
       (math "i"
             "·"
             "Δ"
             (var "u")
             "+"
             (var "u")
             "_"
             "1"
             ","
             "("
             "j"
             "+"
             "1"
             ","
             ")"
             "·"
             "Δ"
             (var "v")
             "+"
             (var "v")
             "_"
             "1")
       " );
   }
   glEnd();
} ")
     (para "
If "
           (var "mode")
           " is "
           (code "GL_LINE")
           ", then a call to "
           (code "glEvalMesh2")
           " is equivalent to: ")
     (para)
     (example
       "
for ( j = "
       (var "j1")
       "; j <= "
       (var "j2")
       "; j += 1 ) {
   glBegin( GL_LINE_STRIP );
   for ( i = "
       (var "i1")
       "; i <= "
       (var "i2")
       "; i += 1 )
      glEvalCoord2( "
       (math "i"
             "·"
             "Δ"
             (var "u")
             "+"
             (var "u")
             "_"
             "1"
             ","
             "j"
             "·"
             "Δ"
             (var "v")
             "+"
             (var "v")
             "_"
             "1")
       " );
   glEnd();
}

for ( i = "
       (var "i1")
       ";  i <= "
       (var "i2")
       "; i += 1 ) {
   glBegin( GL_LINE_STRIP );
   for ( j = "
       (var "j1")
       "; j <= "
       (var "j1")
       "; j += 1 )
      glEvalCoord2( "
       (math "i"
             "·"
             "Δ"
             (var "u")
             "+"
             (var "u")
             "_"
             "1"
             ","
             "j"
             "·"
             "Δ"
             (var "v")
             "+"
             (var "v")
             "_"
             "1")
       " );
   glEnd();
} ")
     (para "
And finally, if "
           (var "mode")
           " is "
           (code "GL_POINT")
           ", then a call to "
           (code "glEvalMesh2")
           " is equivalent to: ")
     (para)
     (example
       "
glBegin( GL_POINTS );
for ( j = "
       (var "j1")
       "; j <= "
       (var "j2")
       "; j += 1 )
   for ( i = "
       (var "i1")
       "; i <= "
       (var "i2")
       "; i += 1 )
      glEvalCoord2( "
       (math "i"
             "·"
             "Δ"
             (var "u")
             "+"
             (var "u")
             "_"
             "1"
             ","
             "j"
             "·"
             "Δ"
             (var "v")
             "+"
             (var "v")
             "_"
             "1")
       " );
glEnd(); ")
     (para "
In all three cases, the only absolute numeric requirements are that if "
           (math (var "i") "=" (var "n"))
           ",
            then the value computed from "
           (math (var "i")
                 "·"
                 "Δ"
                 (var "u")
                 "+"
                 (var "u")
                 "_"
                 "1")
           "
is exactly "
           (math (var "u") "_" "2")
           ",
            and if "
           (math (var "j") "=" (var "m"))
           ",
            then the value computed from "
           (math (var "j")
                 "·"
                 "Δ"
                 (var "v")
                 "+"
                 (var "v")
                 "_"
                 "1")
           "
is exactly "
           (math (var "v") "_" "2")
           ". ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "mode")
           " is not an accepted value. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glEvalMesh")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glEvalPoint
  "glEvalPoint"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glEvalPoint1"))
      (paramdef "GLint " (parameter "i"))))
  '(*fragment*
     (heading
       "generate and evaluate a single point in a mesh")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "i")))
                   (para "
Specifies the integer value for grid domain variable "
                         (math (var "i"))
                         ". "))
            (entry (% (heading (var "j")))
                   (para "
Specifies the integer value for grid domain variable "
                         (math (var "j"))
                         "
("
                         (code "glEvalPoint2")
                         " only). ")))
     (heading "Description")
     (para (code "glMapGrid")
           " and "
           (code "glEvalMesh")
           " are used in tandem to efficiently
            generate and evaluate a series of evenly spaced map domain values. "
           (code "glEvalPoint")
           " can be used to evaluate a single grid point in the same gridspace
            that is traversed by "
           (code "glEvalMesh")
           ".
            Calling "
           (code "glEvalPoint1")
           " is equivalent to calling "
           "
where "
           (math "Δ"
                 (var "u")
                 "="
                 "("
                 (var "u")
                 "_"
                 "2"
                 "-"
                 (var "u")
                 "_"
                 "1"
                 ","
                 ")"
                 "/"
                 (var "n")))
     (example
       "
glEvalCoord1( "
       (math "i"
             "·"
             "Δ"
             (var "u")
             "+"
             (var "u")
             "_"
             "1")
       " ); ")
     (para "
and "
           (math (var "n"))
           ", "
           (math (var "u") "_" "1")
           ",
            and "
           (math (var "u") "_" "2")
           "
are the arguments to the most recent "
           (code "glMapGrid1")
           " command.
            The one absolute numeric requirement is that if "
           (math (var "i") "=" (var "n"))
           ",
            then the value computed from "
           (math (var "i")
                 "·"
                 "Δ"
                 (var "u")
                 "+"
                 (var "u")
                 "_"
                 "1")
           "
is exactly "
           (math (var "u") "_" "2")
           ". ")
     (para "
In the two-dimensional case, "
           (code "glEvalPoint2")
           ", let ")
     (para (math "Δ"
                 (var "u")
                 "="
                 "("
                 (var "u")
                 "_"
                 "2"
                 "-"
                 (var "u")
                 "_"
                 "1"
                 ","
                 ")"
                 "/"
                 (var "n"))
           (para (math "Δ"
                       (var "v")
                       "="
                       "("
                       (var "v")
                       "_"
                       "2"
                       "-"
                       (var "v")
                       "_"
                       "1"
                       ","
                       ")"
                       "/"
                       (var "m"))))
     (para "
where "
           (math (var "n"))
           ", "
           (math (var "u") "_" "1")
           ", "
           (math (var "u") "_" "2")
           ", "
           (math (var "m"))
           ", "
           (math (var "v") "_" "1")
           ",
            and "
           (math (var "v") "_" "2")
           "
are the arguments to the most recent "
           (code "glMapGrid2")
           " command.
            Then the "
           (code "glEvalPoint2")
           " command is equivalent to calling "
           "
The only absolute numeric requirements are that if "
           (math (var "i") "=" (var "n"))
           ",
            then the value computed from "
           (math (var "i")
                 "·"
                 "Δ"
                 (var "u")
                 "+"
                 (var "u")
                 "_"
                 "1")
           "
is exactly "
           (math (var "u") "_" "2")
           ",
            and if "
           (math (var "j") "=" (var "m"))
           ",
            then the value computed from "
           (math (var "j")
                 "·"
                 "Δ"
                 (var "v")
                 "+"
                 (var "v")
                 "_"
                 "1")
           "
is exactly "
           (math (var "v") "_" "2")
           ". ")
     (example
       "
glEvalCoord2( "
       (math "i"
             "·"
             "Δ"
             (var "u")
             "+"
             (var "u")
             "_"
             "1"
             ","
             "j"
             "·"
             "Δ"
             (var "v")
             "+"
             (var "v")
             "_"
             "1")
       " ); ")))

(define-gl-procedure
  glFeedbackBuffer
  "glFeedbackBuffer"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glFeedbackBuffer"))
      (paramdef "GLsizei " (parameter "size"))
      (paramdef "GLenum " (parameter "type"))
      (paramdef "GLfloat * " (parameter "buffer"))))
  '(*fragment*
     (heading "controls feedback mode")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "size")))
                   (para "
Specifies the maximum number of values that can be written into "
                         (var "buffer")
                         ". "))
            (entry (% (heading (var "type")))
                   (para "
Specifies a symbolic constant that describes the information
                    that will be returned for each vertex. "
                         (code "GL_2D")
                         ", "
                         (code "GL_3D")
                         ", "
                         (code "GL_3D_COLOR")
                         ", "
                         (code "GL_3D_COLOR_TEXTURE")
                         ", and "
                         (code "GL_4D_COLOR_TEXTURE")
                         " are accepted. "))
            (entry (% (heading (var "buffer")))
                   (para "
Returns the feedback data. ")))
     (heading "Description")
     (para "
The "
           (code "glFeedbackBuffer")
           " function controls feedback.
            Feedback, like selection, is a GL mode.
            The mode is selected by calling "
           (code "glRenderMode")
           " with "
           (code "GL_FEEDBACK")
           ".
            When the GL is in feedback mode,
            no pixels are produced by rasterization.
            Instead, information about primitives that would have been
            rasterized is fed back to the application using the GL. ")
     (para (code "glFeedbackBuffer")
           " has three arguments: "
           (var "buffer")
           " is a pointer to an array of floating-point values
            into which feedback information is placed. "
           (var "size")
           " indicates the size of the array. "
           (var "type")
           " is a symbolic constant describing the information
            that is fed back for each vertex. "
           (code "glFeedbackBuffer")
           " must be issued before feedback mode is enabled
            (by calling "
           (code "glRenderMode")
           " with argument "
           (code "GL_FEEDBACK")
           ").
            Setting "
           (code "GL_FEEDBACK")
           " without establishing the feedback buffer,
            or calling "
           (code "glFeedbackBuffer")
           " while the GL is in feedback mode,
            is an error. ")
     (para "
When "
           (code "glRenderMode")
           " is called while in feedback mode, it returns the number of entries
            placed in the feedback array and resets the feedback array pointer to the base
            of the feedback buffer. The returned value never exceeds "
           (var "size")
           ". If the feedback
            data required more room than was available in "
           (var "buffer")
           ", "
           (code "glRenderMode")
           " returns a negative value.
            To take the GL out of feedback mode, call "
           (code "glRenderMode")
           " with a parameter value other than "
           (code "GL_FEEDBACK")
           ". ")
     (para "
While in feedback mode,
            each primitive, bitmap, or pixel rectangle that would be rasterized
            generates a block of values that are copied into the feedback array.
            If doing so would cause the number of entries to exceed the maximum,
            the block is partially written so as to fill the array
            (if there is any room left at all),
            and an overflow flag is set.
            Each block begins with a code indicating the primitive type,
            followed by values that describe the primitive's vertices and
            associated data.
            Entries are also written for bitmaps and pixel rectangles.
            Feedback occurs after polygon culling and "
           (code "glPolygonMode")
           " interpretation
            of polygons has taken place,
            so polygons that are culled are not returned in the feedback buffer.
            It can also occur after polygons with more than three edges are broken up
            into triangles,
            if the GL implementation renders polygons by performing this decomposition. ")
     (para "
The "
           (code "glPassThrough")
           " command can be used to insert a marker
            into the feedback buffer.
            See "
           (code "glPassThrough")
           ". ")
     (para "
Following is the grammar for the blocks of values written
            into the feedback buffer.
            Each primitive is indicated with a unique identifying value
            followed by some number of vertices.
            Polygon entries include an integer value indicating how many vertices follow.
            A vertex is fed back as some number of floating-point values,
            as determined by "
           (var "type")
           ".
            Colors are fed back as four values in RGBA mode and one value
            in color index mode. ")
     (para (para "
feedbackList "
                 (math "←")
                 " feedbackItem feedbackList | feedbackItem ")
           (para "
feedbackItem "
                 (math "←")
                 " point | lineSegment | polygon | bitmap | pixelRectangle | passThru ")
           (para "
point "
                 (math "←")
                 (code "GL_POINT_TOKEN")
                 " vertex ")
           (para "
lineSegment "
                 (math "←")
                 (code "GL_LINE_TOKEN")
                 " vertex vertex | "
                 (code "GL_LINE_RESET_TOKEN")
                 " vertex vertex ")
           (para "
polygon "
                 (math "←")
                 (code "GL_POLYGON_TOKEN")
                 " n polySpec ")
           (para "
polySpec "
                 (math "←")
                 " polySpec vertex | vertex vertex vertex ")
           (para "
bitmap "
                 (math "←")
                 (code "GL_BITMAP_TOKEN")
                 " vertex ")
           (para "
pixelRectangle "
                 (math "←")
                 (code "GL_DRAW_PIXEL_TOKEN")
                 " vertex | "
                 (code "GL_COPY_PIXEL_TOKEN")
                 " vertex ")
           (para "
passThru "
                 (math "←")
                 (code "GL_PASS_THROUGH_TOKEN")
                 " value ")
           (para "
vertex "
                 (math "←")
                 " 2d | 3d | 3dColor | 3dColorTexture | 4dColorTexture ")
           (para "
2d " (math "←") " value value ")
           (para "
3d " (math "←") " value value value ")
           (para "
3dColor "
                 (math "←")
                 " value value value color ")
           (para "
3dColorTexture "
                 (math "←")
                 " value value value color tex ")
           (para "
4dColorTexture "
                 (math "←")
                 " value value value value color tex ")
           (para "
color " (math "←") " rgba | index ")
           (para "
rgba "
                 (math "←")
                 " value value value value ")
           (para "
index " (math "←") " value ")
           (para "
tex "
                 (math "←")
                 " value value value value ")
           (para))
     (para (var "value")
           "
is a floating-point number,
            and "
           (var "n")
           "
is a floating-point integer giving the number of vertices in the polygon. "
           (code "GL_POINT_TOKEN")
           ", "
           (code "GL_LINE_TOKEN")
           ", "
           (code "GL_LINE_RESET_TOKEN")
           ", "
           (code "GL_POLYGON_TOKEN")
           ", "
           (code "GL_BITMAP_TOKEN")
           ", "
           (code "GL_DRAW_PIXEL_TOKEN")
           ", "
           (code "GL_COPY_PIXEL_TOKEN")
           " and "
           (code "GL_PASS_THROUGH_TOKEN")
           " are symbolic floating-point constants. "
           (code "GL_LINE_RESET_TOKEN")
           " is returned whenever the line stipple pattern
            is reset.
            The data returned as a vertex depends on the feedback "
           (var "type")
           ". ")
     (para "
The following table gives the correspondence between "
           (var "type")
           "
and the number of values per vertex. "
           (var "k")
           " is 1 in color index mode and 4 in RGBA mode. ")
     (para)
     (table (% (formatter (asis)))
            (entry (% (heading (strong "Type")))
                   (para (strong "Coordinates")
                         ", "
                         (strong "Color")
                         ", "
                         (strong "Texture")
                         ", "
                         (strong "Total Number of Values")))
            (entry (% (heading (code "GL_2D")))
                   (para (var "x")
                         ", "
                         (var "y")
                         ", "
                         ", "
                         ", "
                         "
2 "))
            (entry (% (heading (code "GL_3D")))
                   (para (var "x")
                         ", "
                         (var "y")
                         ", "
                         (var "z")
                         ", "
                         ", "
                         ", "
                         "
3 "))
            (entry (% (heading (code "GL_3D_COLOR")))
                   (para (var "x")
                         ", "
                         (var "y")
                         ", "
                         (var "z")
                         ", "
                         (math (var "k"))
                         ", "
                         ", "
                         (math "3" "+" (var "k"))))
            (entry (% (heading (code "GL_3D_COLOR_TEXTURE")))
                   (para (var "x")
                         ", "
                         (var "y")
                         ", "
                         (var "z")
                         ", "
                         (math (var "k"))
                         ", "
                         "
4 "
                         ", "
                         (math "7" "+" (var "k"))))
            (entry (% (heading (code "GL_4D_COLOR_TEXTURE")))
                   (para (var "x")
                         ", "
                         (var "y")
                         ", "
                         (var "z")
                         ", "
                         (var "w")
                         ", "
                         (math (var "k"))
                         ", "
                         "
4 "
                         ", "
                         (math "8" "+" (var "k")))))
     (para "
Feedback vertex coordinates are in window coordinates,
            except "
           (var "w")
           ",
            which is in clip coordinates.
            Feedback colors are lighted, if lighting is enabled.
            Feedback texture coordinates are generated,
            if texture coordinate generation is enabled.
            They are always transformed by the texture matrix. ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "type")
           " is not an accepted value. ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "size")
           " is negative. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glFeedbackBuffer")
           " is called while the
            render mode is "
           (code "GL_FEEDBACK")
           ",
            or if "
           (code "glRenderMode")
           " is called with argument "
           (code "GL_FEEDBACK")
           " before "
           (code "glFeedbackBuffer")
           " is called at least once. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glFeedbackBuffer")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glFinish
  "glFinish"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glFinish"))
      (paramdef (parameter "void"))))
  '(*fragment*
     (heading
       "block until all GL execution is complete")
     (heading "Description")
     (para (code "glFinish")
           " does not return until the effects of all previously
            called GL commands are complete.
            Such effects include all changes to GL state,
            all changes to connection state,
            and all changes to the frame buffer contents. ")
     (heading "Errors")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glFinish")
           " is executed between
            the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glFlush
  "glFlush"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glFlush"))
      (paramdef (parameter "void"))))
  '(*fragment*
     (heading
       "force execution of GL commands in finite time")
     (heading "Description")
     (para "
Different GL implementations buffer commands in several different locations,
            including network buffers and the graphics accelerator itself. "
           (code "glFlush")
           " empties all of these buffers,
            causing all issued commands to be executed as quickly as
            they are accepted by the actual rendering engine.
            Though this execution may not be completed in any particular
            time period,
            it does complete in finite time. ")
     (para "
Because any GL program might be executed over a network,
            or on an accelerator that buffers commands,
            all programs should call "
           (code "glFlush")
           " whenever they count on having
            all of their previously issued commands completed.
            For example,
            call "
           (code "glFlush")
           " before waiting for user input that depends on
            the generated image. ")
     (heading "Errors")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glFlush")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glFogCoordPointer
  "glFogCoordPointer"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glFogCoordPointer"))
      (paramdef "GLenum " (parameter "type"))
      (paramdef "GLsizei " (parameter "stride"))
      (paramdef "GLvoid * " (parameter "pointer"))))
  '(*fragment*
     (heading "define an array of fog coordinates")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "type")))
                   (para "
Specifies the data type of each fog coordinate.
                    Symbolic constants "
                         (code "GL_FLOAT")
                         ",
                    or "
                         (code "GL_DOUBLE")
                         "
are accepted. The initial value is "
                         (code "GL_FLOAT")
                         ". "))
            (entry (% (heading (var "stride")))
                   (para "
Specifies the byte offset between consecutive fog coordinates.
                    If "
                         (var "stride")
                         " is 0, the array elements are understood
                    to be tightly packed. The initial value is 0. "))
            (entry (% (heading (var "pointer")))
                   (para "
Specifies a pointer to the first coordinate of the first fog coordinate in the
                    array. The initial value is 0. ")))
     (heading "Description")
     (para (code "glFogCoordPointer")
           " specifies the location and data format of an array of fog coordinates
            to use when rendering. "
           (var "type")
           " specifies the data type of each fog
            coordinate, and "
           (var "stride")
           " specifies the byte stride from one fog coordinate to
            the next, allowing vertices and attributes to be packed into a single array
            or stored in separate arrays. ")
     (para "
If a non-zero named buffer object is bound to the "
           (code "GL_ARRAY_BUFFER")
           " target 
            (see "
           (code "glBindBuffer")
           ") while a fog coordinate array is
            specified, "
           (var "pointer")
           " is treated as a byte offset into the buffer object's data store.
            Also, the buffer object binding ("
           (code "GL_ARRAY_BUFFER_BINDING")
           ") is saved as fog coordinate vertex array
            client-side state ("
           (code "GL_FOG_COORD_ARRAY_BUFFER_BINDING")
           "). ")
     (para "
When a fog coordinate array is specified, "
           (var "type")
           ", "
           (var "stride")
           ", and "
           (var "pointer")
           " are saved as client-side
            state, in addition to the current vertex array buffer object binding. ")
     (para "
To enable and disable the fog coordinate array, call "
           (code "glEnableClientState")
           " and "
           (code "glDisableClientState")
           " with the argument "
           (code "GL_FOG_COORD_ARRAY")
           ". If
            enabled, the fog coordinate array is used
            when "
           (code "glDrawArrays")
           ", "
           (code "glMultiDrawArrays")
           ", "
           (code "glDrawElements")
           ", "
           (code "glMultiDrawElements")
           ", "
           (code "glDrawRangeElements")
           ", or "
           (code "glArrayElement")
           " is called. ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "type")
           " is not either "
           (code "GL_FLOAT")
           "
or "
           (code "GL_DOUBLE")
           ". ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "stride")
           " is negative. ")))

(define-gl-procedure
  glFogCoord
  "glFogCoord"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glFogCoordd"))
      (paramdef "GLdouble " (parameter "coord"))))
  '(*fragment*
     (heading "set the current fog coordinates")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "coord")))
                   (para "
Specify the fog distance. ")))
     (heading "Description")
     (para (code "glFogCoord")
           " specifies the fog coordinate that is associated with each vertex and
            the current raster position.  The value specified is interpolated and used
            in computing the fog color (see "
           (code "glFog")
           "). ")))

(define-gl-procedure
  glFog
  "glFog"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glFogf"))
      (paramdef "GLenum " (parameter "pname"))
      (paramdef "GLfloat " (parameter "param"))))
  '(*fragment*
     (heading "specify fog parameters")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "pname")))
                   (para "
Specifies a single-valued fog parameter. "
                         (code "GL_FOG_MODE")
                         ", "
                         (code "GL_FOG_DENSITY")
                         ", "
                         (code "GL_FOG_START")
                         ", "
                         (code "GL_FOG_END")
                         ", "
                         (code "GL_FOG_INDEX")
                         ", and "
                         (code "GL_FOG_COORD_SRC")
                         "
are accepted. "))
            (entry (% (heading (var "param")))
                   (para "
Specifies the value that "
                         (var "pname")
                         " will be set to. ")))
     (heading "Description")
     (para "
Fog is initially disabled.
            While enabled, fog affects rasterized geometry,
            bitmaps, and pixel blocks, but not buffer clear operations. To enable
            and disable fog, call "
           (code "glEnable")
           " and "
           (code "glDisable")
           " with argument "
           (code "GL_FOG")
           ". ")
     (para (code "glFog")
           " assigns the value or values in "
           (var "params")
           " to the fog parameter
            specified by "
           (var "pname")
           ".
            The following values are accepted for "
           (var "pname")
           ": ")
     (table (% (formatter (asis)))
            (entry (% (heading (code "GL_FOG_MODE")))
                   (para (var "params")
                         " is a single integer or floating-point value that specifies
                        the equation to be used to compute the fog blend factor, "
                         (math (var "f"))
                         ".
                        Three symbolic constants are accepted: "
                         (code "GL_LINEAR")
                         ", "
                         (code "GL_EXP")
                         ",
                        and "
                         (code "GL_EXP2")
                         ".
                        The equations corresponding to these symbolic constants are defined below.
                        The initial fog mode is "
                         (code "GL_EXP")
                         ". "))
            (entry (% (heading (code "GL_FOG_DENSITY")))
                   (para (var "params")
                         " is a single integer or floating-point value that specifies "
                         (math (var "density"))
                         ",
                        the fog density used in both exponential fog equations.
                        Only nonnegative densities are accepted.
                        The initial fog density is 1. "))
            (entry (% (heading (code "GL_FOG_START")))
                   (para (var "params")
                         " is a single integer or floating-point value that specifies "
                         (math (var "start"))
                         ",
                        the near distance used in the linear fog equation.
                        The initial near distance is 0. "))
            (entry (% (heading (code "GL_FOG_END")))
                   (para (var "params")
                         " is a single integer or floating-point value that specifies "
                         (math (var "end"))
                         ",
                        the far distance used in the linear fog equation.
                        The initial far distance is 1. "))
            (entry (% (heading (code "GL_FOG_INDEX")))
                   (para (var "params")
                         " is a single integer or floating-point value that specifies "
                         (math (var "i") "_" (var "f"))
                         ",
                        the fog color index.
                        The initial fog index is 0. "))
            (entry (% (heading (code "GL_FOG_COLOR")))
                   (para (var "params")
                         " contains four integer or floating-point values that specify "
                         (math (var "C") "_" (var "f"))
                         ",
                        the fog color.
                        Integer values are mapped linearly such that the most positive representable
                        value maps to 1.0,
                        and the most negative representable value maps to "
                         (math "-1.0")
                         ".
                        Floating-point values are mapped directly.
                        After conversion,
                        all color components are clamped to the range "
                         (math "[" "0" "," "1" "]")
                         ".
                        The initial fog color is (0, 0, 0, 0). "))
            (entry (% (heading (code "GL_FOG_COORD_SRC")))
                   (para (var "params")
                         " contains either of the following symbolic constants: "
                         (code "GL_FOG_COORD")
                         " or "
                         (code "GL_FRAGMENT_DEPTH")
                         ". "
                         (code "GL_FOG_COORD")
                         "
specifies that the current fog coordinate should be used as distance value
                        in the fog color computation. "
                         (code "GL_FRAGMENT_DEPTH")
                         " specifies that the
                        current fragment depth should be used as distance value in the fog
                        computation. ")))
     (para "
Fog blends a fog color with each rasterized pixel fragment's post-texturing
            color using a blending factor "
           (math (var "f"))
           ".
            Factor "
           (math (var "f"))
           "
is computed in one of three ways,
            depending on the fog mode.
            Let "
           (math (var "c"))
           "
be either the distance in eye coordinate from the origin (in the
            case that the "
           (code "GL_FOG_COORD_SRC")
           " is "
           (code "GL_FRAGMENT_DEPTH")
           ") or
            the current fog coordinate (in the case that "
           (code "GL_FOG_COORD_SRC")
           "
is "
           (code "GL_FOG_COORD")
           ").
            The equation for "
           (code "GL_LINEAR")
           " fog is "
           (math (var "f")
                 "="
                 (var "end")
                 "-"
                 (var "c")
                 ","
                 "/"
                 (var "end")
                 "-"
                 (var "start")
                 ","))
     (para "
The equation for "
           (code "GL_EXP")
           " fog is "
           (math (var "f")
                 "="
                 (var "e")
                 "^"
                 "-"
                 "("
                 (var "density")
                 "·"
                 (var "c")
                 ","
                 ")"
                 ","))
     (para "
The equation for "
           (code "GL_EXP2")
           " fog is "
           (math (var "f")
                 "="
                 (var "e")
                 "^"
                 "-"
                 "("
                 (var "density")
                 "·"
                 (var "c")
                 ","
                 ")"
                 ","
                 "^"
                 "2"))
     (para "
Regardless of the fog mode, "
           (math (var "f"))
           "
is clamped to the range "
           (math "[" "0" "," "1" "]")
           "
after it is computed.
            Then,
            if the GL is in RGBA color mode,
            the fragment's red, green, and blue colors, represented by "
           (math (var "C") "_" (var "r"))
           ",
            are replaced by ")
     (para (math (var "C")
                 "_"
                 (var "r")
                 ","
                 "^"
                 "″"
                 "="
                 (var "f")
                 "×"
                 (var "C")
                 "_"
                 (var "r")
                 "+"
                 "("
                 "1"
                 "-"
                 (var "f")
                 ","
                 ")"
                 "×"
                 (var "C")
                 "_"
                 (var "f")))
     (para "
Fog does not affect a fragment's alpha component. ")
     (para "
In color index mode, the fragment's color index "
           (math (var "i") "_" (var "r"))
           "
is replaced by ")
     (para (math (var "i")
                 "_"
                 (var "r")
                 ","
                 "^"
                 "″"
                 "="
                 (var "i")
                 "_"
                 (var "r")
                 "+"
                 "("
                 "1"
                 "-"
                 (var "f")
                 ","
                 ")"
                 "×"
                 (var "i")
                 "_"
                 (var "f")))
     (para)
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "pname")
           " is not an accepted value,
            or if "
           (var "pname")
           " is "
           (code "GL_FOG_MODE")
           " and "
           (var "params")
           " is not an accepted value. ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "pname")
           " is "
           (code "GL_FOG_DENSITY")
           "
and "
           (var "params")
           " is negative. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glFog")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glFrontFace
  "glFrontFace"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glFrontFace"))
      (paramdef "GLenum " (parameter "mode"))))
  '(*fragment*
     (heading
       "define front- and back-facing polygons")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "mode")))
                   (para "
Specifies the orientation of front-facing polygons. "
                         (code "GL_CW")
                         " and "
                         (code "GL_CCW")
                         " are accepted.
                    The initial value is "
                         (code "GL_CCW")
                         ". ")))
     (heading "Description")
     (para "
In a scene composed entirely of opaque closed surfaces,
            back-facing polygons are never visible.
            Eliminating these invisible polygons has the obvious benefit
            of speeding up the rendering of the image.
            To enable and disable elimination of back-facing polygons, call "
           (code "glEnable")
           "
and "
           (code "glDisable")
           " with argument "
           (code "GL_CULL_FACE")
           ". ")
     (para "
The projection of a polygon to window coordinates is said to have
            clockwise winding if an imaginary object following the path
            from its first vertex,
            its second vertex,
            and so on,
            to its last vertex,
            and finally back to its first vertex,
            moves in a clockwise direction about the interior of the polygon.
            The polygon's winding is said to be counterclockwise if the imaginary
            object following the same path moves in a counterclockwise direction
            about the interior of the polygon. "
           (code "glFrontFace")
           " specifies whether polygons with clockwise winding in window coordinates,
            or counterclockwise winding in window coordinates,
            are taken to be front-facing.
            Passing "
           (code "GL_CCW")
           " to "
           (var "mode")
           " selects counterclockwise polygons as
            front-facing; "
           (code "GL_CW")
           " selects clockwise polygons as front-facing.
            By default, counterclockwise polygons are taken to be front-facing. ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "mode")
           " is not an accepted value. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glFrontFace")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glFrustum
  "glFrustum"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glFrustum"))
      (paramdef "GLdouble " (parameter "left"))
      (paramdef "GLdouble " (parameter "right"))
      (paramdef "GLdouble " (parameter "bottom"))
      (paramdef "GLdouble " (parameter "top"))
      (paramdef "GLdouble " (parameter "nearVal"))
      (paramdef "GLdouble " (parameter "farVal"))))
  '(*fragment*
     (heading
       "multiply the current matrix by a perspective matrix")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "left")))
                   (itemx (var "right"))
                   (para "
Specify the coordinates for the left and right vertical clipping planes. "))
            (entry (% (heading (var "bottom")))
                   (itemx (var "top"))
                   (para "
Specify the coordinates for the bottom and top horizontal clipping planes. "))
            (entry (% (heading (var "nearVal")))
                   (itemx (var "farVal"))
                   (para "
Specify the distances to the near and far depth clipping planes.
                    Both distances must be positive. ")))
     (heading "Description")
     (para (code "glFrustum")
           " describes a perspective matrix that produces a perspective projection.
            The current matrix (see "
           (code "glMatrixMode")
           ") is multiplied by this matrix
            and the result replaces the current matrix, as if "
           (code "glMultMatrix")
           " were called with the following matrix
            as its argument: ")
     (para)
     (para (math "["
                 "("
                 "2"
                 "\u2062"
                 (var "nearVal")
                 ","
                 "/"
                 (var "right")
                 "-"
                 (var "left")
                 ","
                 ","
                 " "
                 "0"
                 " "
                 (var "A")
                 " "
                 "0"
                 ")"
                 ", "
                 "("
                 "0"
                 " "
                 "2"
                 "\u2062"
                 (var "nearVal")
                 ","
                 "/"
                 (var "top")
                 "-"
                 (var "bottom")
                 ","
                 ","
                 " "
                 (var "B")
                 " "
                 "0"
                 ")"
                 ", "
                 "("
                 "0"
                 " "
                 "0"
                 " "
                 (var "C")
                 " "
                 (var "D")
                 ")"
                 ", "
                 "("
                 "0"
                 " "
                 "0"
                 " "
                 "-1"
                 " "
                 "0"
                 ")"
                 ","
                 "]"))
     (para (math (var "A")
                 "="
                 (var "right")
                 "+"
                 (var "left")
                 ","
                 "/"
                 (var "right")
                 "-"
                 (var "left")
                 ","))
     (para (math (var "B")
                 "="
                 (var "top")
                 "+"
                 (var "bottom")
                 ","
                 "/"
                 (var "top")
                 "-"
                 (var "bottom")
                 ","))
     (para (math (var "C")
                 "="
                 "-"
                 (var "farVal")
                 "+"
                 (var "nearVal")
                 ","
                 "/"
                 (var "farVal")
                 "-"
                 (var "nearVal")
                 ","
                 ","))
     (para (math (var "D")
                 "="
                 "-"
                 "2"
                 "\u2062"
                 (var "farVal")
                 "\u2062"
                 (var "nearVal")
                 ","
                 "/"
                 (var "farVal")
                 "-"
                 (var "nearVal")
                 ","
                 ","))
     (para)
     (para "
Typically, the matrix mode is "
           (code "GL_PROJECTION")
           ", and "
           (math "("
                 (var "left")
                 ","
                 (var "bottom")
                 "-"
                 (var "nearVal")
                 ")")
           "
and "
           (math "("
                 (var "right")
                 ","
                 (var "top")
                 "-"
                 (var "nearVal")
                 ")")
           "
specify the points on the near clipping plane that are mapped
            to the lower left and upper right corners of the window,
            assuming that the eye is located at (0, 0, 0). "
           (math "-" (var "farVal"))
           "
specifies the location of the far clipping plane.
            Both "
           (var "nearVal")
           " and "
           (var "farVal")
           " must be positive. ")
     (para "
Use "
           (code "glPushMatrix")
           " and "
           (code "glPopMatrix")
           " to save and restore
            the current matrix stack. ")
     (heading "Errors")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "nearVal")
           " or "
           (var "farVal")
           " is not
            positive, or if "
           (var "left")
           " = "
           (var "right")
           ", or "
           (var "bottom")
           " = "
           (var "top")
           ",
            or "
           (var "near")
           " = "
           (var "far")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glFrustum")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glGenBuffers
  "glGenBuffers"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glGenBuffers"))
      (paramdef "GLsizei " (parameter "n"))
      (paramdef "GLuint * " (parameter "buffers"))))
  '(*fragment*
     (heading "generate buffer object names")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "n")))
                   (para "
Specifies the number of buffer object names to be generated. "))
            (entry (% (heading (var "buffers")))
                   (para "
Specifies an array in which the generated buffer object names are stored. ")))
     (heading "Description")
     (para (code "glGenBuffers")
           " returns "
           (var "n")
           " buffer object names in "
           (var "buffers")
           ".
            There is no guarantee that the names form a contiguous set of integers;
            however, it is guaranteed that none of the returned names was in use
            immediately before the call to "
           (code "glGenBuffers")
           ". ")
     (para "
Buffer object names returned by a call to "
           (code "glGenBuffers")
           " are not returned by
            subsequent calls, unless they are first deleted with "
           (code "glDeleteBuffers")
           ". ")
     (para "
No buffer objects are associated with the returned buffer object names until they are first bound by calling "
           (code "glBindBuffer")
           ". ")
     (heading "Errors")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "n")
           " is negative. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glGenBuffers")
           " is executed
            between the execution of "
           (code "glBegin")
           " and the corresponding
            execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glGenLists
  "glGenLists"
  (funcsynopsis
    (funcprototype
      (funcdef "GLuint " (function "glGenLists"))
      (paramdef "GLsizei " (parameter "range"))))
  '(*fragment*
     (heading
       "generate a contiguous set of empty display lists")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "range")))
                   (para "
Specifies the number of contiguous empty display lists
                    to be generated. ")))
     (heading "Description")
     (para (code "glGenLists")
           " has one argument, "
           (var "range")
           ".
            It returns an integer "
           (var "n")
           " such that "
           (var "range")
           " contiguous
            empty display lists,
            named "
           (math (var "n"))
           ", "
           (math (var "n") "+" "1")
           ", "
           (math (var "..."))
           ", "
           (math (var "n") "+" (var "range") "-" "1")
           ",
            are created.
            If "
           (var "range")
           " is 0,
            if there is no group of "
           (var "range")
           " contiguous names available,
            or if any error is generated,
            no display lists are generated,
            and 0 is returned. ")
     (heading "Errors")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "range")
           " is negative. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glGenLists")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glGenQueries
  "glGenQueries"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glGenQueries"))
      (paramdef "GLsizei " (parameter "n"))
      (paramdef "GLuint * " (parameter "ids"))))
  '(*fragment*
     (heading "generate query object names")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "n")))
                   (para "
Specifies the number of query object names to be generated. "))
            (entry (% (heading (var "ids")))
                   (para "
Specifies an array in which the generated query object names are stored. ")))
     (heading "Description")
     (para (code "glGenQueries")
           " returns "
           (var "n")
           " query object names in "
           (var "ids")
           ".
            There is no guarantee that the names form a contiguous set of integers;
            however, it is guaranteed that none of the returned names was in use
            immediately before the call to "
           (code "glGenQueries")
           ". ")
     (para "
Query object names returned by a call to "
           (code "glGenQueries")
           " are not returned by
            subsequent calls, unless they are first deleted with "
           (code "glDeleteQueries")
           ". ")
     (para "
No query objects are associated with the returned query object names until they are first used by calling "
           (code "glBeginQuery")
           ". ")
     (heading "Errors")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "n")
           " is negative. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glGenQueries")
           " is executed
            between the execution of "
           (code "glBegin")
           " and the corresponding
            execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glGenTextures
  "glGenTextures"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glGenTextures"))
      (paramdef "GLsizei " (parameter "n"))
      (paramdef "GLuint * " (parameter "textures"))))
  '(*fragment*
     (heading "generate texture names")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "n")))
                   (para "
Specifies the number of texture names to be generated. "))
            (entry (% (heading (var "textures")))
                   (para "
Specifies an array in which the generated texture names are stored. ")))
     (heading "Description")
     (para (code "glGenTextures")
           " returns "
           (var "n")
           " texture names in "
           (var "textures")
           ".
            There is no guarantee that the names form a contiguous set of integers;
            however, it is guaranteed that none of the returned names was in use
            immediately before the call to "
           (code "glGenTextures")
           ". ")
     (para "
The generated textures have no dimensionality; they assume the dimensionality
            of the texture target to which they are first bound
            (see "
           (code "glBindTexture")
           "). ")
     (para "
Texture names returned by a call to "
           (code "glGenTextures")
           " are not returned by
            subsequent calls, unless they are first deleted with "
           (code "glDeleteTextures")
           ". ")
     (heading "Errors")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "n")
           " is negative. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glGenTextures")
           " is executed
            between the execution of "
           (code "glBegin")
           " and the corresponding
            execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glGetActiveAttrib
  "glGetActiveAttrib"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glGetActiveAttrib"))
      (paramdef "GLuint " (parameter "program"))
      (paramdef "GLuint " (parameter "index"))
      (paramdef "GLsizei " (parameter "bufSize"))
      (paramdef "GLsizei *" (parameter "length"))
      (paramdef "GLint *" (parameter "size"))
      (paramdef "GLenum *" (parameter "type"))
      (paramdef "GLchar *" (parameter "name"))))
  '(*fragment*
     (heading
       "Returns information about an active attribute variable for the specified program object")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "program")))
                   (para "Specifies the program object to be
\t\t    queried."))
            (entry (% (heading (var "index")))
                   (para "Specifies the index of the attribute variable
\t\t    to be queried."))
            (entry (% (heading (var "bufSize")))
                   (para "Specifies the maximum number of characters
\t\t    OpenGL is allowed to write in the character buffer
\t\t    indicated by "
                         (var "name")
                         "."))
            (entry (% (heading (var "length")))
                   (para "Returns the number of characters actually
\t\t    written by OpenGL in the string indicated by "
                         (var "name")
                         " (excluding the null
\t\t    terminator) if a value other than "
                         (code "NULL")
                         " is passed."))
            (entry (% (heading (var "size")))
                   (para "Returns the size of the attribute
\t\t    variable."))
            (entry (% (heading (var "type")))
                   (para "Returns the data type of the attribute
\t\t    variable."))
            (entry (% (heading (var "name")))
                   (para "Returns a null terminated string containing
\t\t    the name of the attribute variable.")))
     (heading "Description")
     (para (code "glGetActiveAttrib")
           " returns information
\tabout an active attribute variable in the program object
\tspecified by "
           (var "program")
           ". The number of
\tactive attributes can be obtained by calling\t"
           (code "glGetProgram")
           "
with the value "
           (code "GL_ACTIVE_ATTRIBUTES")
           ". A
\tvalue of 0 for "
           (var "index")
           " selects the first
\tactive attribute variable. Permissible values for\t"
           (var "index")
           " range from 0 to the number of
\tactive attribute variables minus 1.")
     (para "A vertex shader may use either built-in attribute
\tvariables, user-defined attribute variables, or both. Built-in
\tattribute variables have a prefix of \"gl_\" and
\treference conventional OpenGL vertex attribtes (e.g.,\t"
           (var "gl_Vertex")
           ",\t"
           (var "gl_Normal")
           ", etc., see the OpenGL Shading
\tLanguage specification for a complete list.) User-defined
\tattribute variables have arbitrary names and obtain their values
\tthrough numbered generic vertex attributes. An attribute
\tvariable (either built-in or user-defined) is considered active
\tif it is determined during the link operation that it may be
\taccessed during program execution. Therefore,\t"
           (var "program")
           " should have previously been the
\ttarget of a call to\t"
           (code "glLinkProgram")
           ",
\tbut it is not necessary for it to have been linked
\tsuccessfully.")
     (para "The size of the character buffer required to store the
\tlongest attribute variable name in\t"
           (var "program")
           " can be obtained by calling\t"
           (code "glGetProgram")
           "
with the value\t"
           (code "GL_ACTIVE_ATTRIBUTE_MAX_LENGTH")
           ". This value
\tshould be used to allocate a buffer of sufficient size to store
\tthe returned attribute name. The size of this character buffer
\tis passed in "
           (var "bufSize")
           ", and a pointer to
\tthis character buffer is passed in\t"
           (var "name")
           ".")
     (para (code "glGetActiveAttrib")
           " returns the name of
\tthe attribute variable indicated by\t"
           (var "index")
           ", storing it in the character buffer
\tspecified by "
           (var "name")
           ". The string returned
\twill be null terminated. The actual number of characters written
\tinto this buffer is returned in "
           (var "length")
           ",
\tand this count does not include the null termination character.
\tIf the length of the returned string is not required, a value of\t"
           (code "NULL")
           " can be passed in the\t"
           (var "length")
           " argument.")
     (para "The "
           (var "type")
           " argument will return a
\tpointer to the attribute variable's data type. The symbolic
\tconstants "
           (code "GL_FLOAT")
           ",\t"
           (code "GL_FLOAT_VEC2")
           ",\t"
           (code "GL_FLOAT_VEC3")
           ",\t"
           (code "GL_FLOAT_VEC4")
           ",\t"
           (code "GL_FLOAT_MAT2")
           ",\t"
           (code "GL_FLOAT_MAT3")
           ",\t"
           (code "GL_FLOAT_MAT4")
           ",\t"
           (code "GL_FLOAT_MAT2x3")
           ",\t"
           (code "GL_FLOAT_MAT2x4")
           ",\t"
           (code "GL_FLOAT_MAT3x2")
           ",\t"
           (code "GL_FLOAT_MAT3x4")
           ",\t"
           (code "GL_FLOAT_MAT4x2")
           ", or\t"
           (code "GL_FLOAT_MAT4x3")
           " may be returned. The\t"
           (var "size")
           " argument will return the size of the
\tattribute, in units of the type returned in\t"
           (var "type")
           ".")
     (para "The list of active attribute variables may include both
\tbuilt-in attribute variables (which begin with the prefix
\t\"gl_\") as well as user-defined attribute variable
\tnames.")
     (para "This function will return as much information as it can
\tabout the specified active attribute variable. If no information
\tis available, "
           (var "length")
           " will be 0, and\t"
           (var "name")
           " will be an empty string. This
\tsituation could occur if this function is called after a link
\toperation that failed. If an error occurs, the return values\t"
           (var "length")
           ", "
           (var "size")
           ",\t"
           (var "type")
           ", and "
           (var "name")
           "
will be unmodified.")
     (heading "Errors")
     (para (code "GL_INVALID_VALUE")
           " is generated if\t"
           (var "program")
           " is not a value generated by
\tOpenGL.")
     (para (code "GL_INVALID_OPERATION")
           " is generated if\t"
           (var "program")
           " is not a program object.")
     (para (code "GL_INVALID_VALUE")
           " is generated if\t"
           (var "index")
           " is greater than or equal to the
\tnumber of active attribute variables in\t"
           (var "program")
           ".")
     (para (code "GL_INVALID_OPERATION")
           " is generated if\t"
           (code "glGetActiveAttrib")
           " is executed between the
\texecution of\t"
           (code "glBegin")
           "
and the corresponding execution of\t"
           (code "glEnd")
           ".")
     (para (code "GL_INVALID_VALUE")
           " is generated if\t"
           (var "bufSize")
           " is less than 0.")))

(define-gl-procedure
  glGetActiveUniform
  "glGetActiveUniform"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glGetActiveUniform"))
      (paramdef "GLuint " (parameter "program"))
      (paramdef "GLuint " (parameter "index"))
      (paramdef "GLsizei " (parameter "bufSize"))
      (paramdef "GLsizei *" (parameter "length"))
      (paramdef "GLint *" (parameter "size"))
      (paramdef "GLenum *" (parameter "type"))
      (paramdef "GLchar *" (parameter "name"))))
  '(*fragment*
     (heading
       "Returns information about an active uniform variable for the specified program object")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "program")))
                   (para "Specifies the program object to be
\t\t    queried."))
            (entry (% (heading (var "index")))
                   (para "Specifies the index of the uniform variable to
\t\t    be queried."))
            (entry (% (heading (var "bufSize")))
                   (para "Specifies the maximum number of characters
\t\t    OpenGL is allowed to write in the character buffer
\t\t    indicated by "
                         (var "name")
                         "."))
            (entry (% (heading (var "length")))
                   (para "Returns the number of characters actually
\t\t    written by OpenGL in the string indicated by "
                         (var "name")
                         " (excluding the null
\t\t    terminator) if a value other than "
                         (code "NULL")
                         " is passed."))
            (entry (% (heading (var "size")))
                   (para "Returns the size of the uniform
\t\t    variable."))
            (entry (% (heading (var "type")))
                   (para "Returns the data type of the uniform
\t\t    variable."))
            (entry (% (heading (var "name")))
                   (para "Returns a null terminated string containing
\t\t    the name of the uniform variable.")))
     (heading "Description")
     (para (code "glGetActiveUniform")
           " returns
\tinformation about an active uniform variable in the program
\tobject specified by "
           (var "program")
           ". The number
\tof active uniform variables can be obtained by calling\t"
           (code "glGetProgram")
           "
with the value "
           (code "GL_ACTIVE_UNIFORMS")
           ". A value
\tof 0 for "
           (var "index")
           " selects the first active
\tuniform variable. Permissible values for\t"
           (var "index")
           " range from 0 to the number of
\tactive uniform variables minus 1.")
     (para "Shaders may use either built-in uniform variables,
\tuser-defined uniform variables, or both. Built-in uniform
\tvariables have a prefix of \"gl_\" and reference
\texisting OpenGL state or values derived from such state (e.g.,\t"
           (var "gl_Fog")
           ",\t"
           (var "gl_ModelViewMatrix")
           ", etc., see the OpenGL
\tShading Language specification for a complete list.)
\tUser-defined uniform variables have arbitrary names and obtain
\ttheir values from the application through calls to\t"
           (code "glUniform")
           ".
\tA uniform variable (either built-in or user-defined) is
\tconsidered active if it is determined during the link operation
\tthat it may be accessed during program execution. Therefore,\t"
           (var "program")
           " should have previously been the
\ttarget of a call to\t"
           (code "glLinkProgram")
           ",
\tbut it is not necessary for it to have been linked
\tsuccessfully.")
     (para "The size of the character buffer required to store the
\tlongest uniform variable name in "
           (var "program")
           "
can be obtained by calling\t"
           (code "glGetProgram")
           "
with the value\t"
           (code "GL_ACTIVE_UNIFORM_MAX_LENGTH")
           ". This value
\tshould be used to allocate a buffer of sufficient size to store
\tthe returned uniform variable name. The size of this character
\tbuffer is passed in "
           (var "bufSize")
           ", and a
\tpointer to this character buffer is passed in\t"
           (var "name."))
     (para (code "glGetActiveUniform")
           " returns the name
\tof the uniform variable indicated by\t"
           (var "index")
           ", storing it in the character buffer
\tspecified by "
           (var "name")
           ". The string returned
\twill be null terminated. The actual number of characters written
\tinto this buffer is returned in "
           (var "length")
           ",
\tand this count does not include the null termination character.
\tIf the length of the returned string is not required, a value of\t"
           (code "NULL")
           " can be passed in the\t"
           (var "length")
           " argument.")
     (para "The "
           (var "type")
           "
argument will return a pointer to the uniform variable's data
\ttype. The symbolic constants\t"
           (code "GL_FLOAT")
           ",\t"
           (code "GL_FLOAT_VEC2")
           ",\t"
           (code "GL_FLOAT_VEC3")
           ",\t"
           (code "GL_FLOAT_VEC4")
           ",\t"
           (code "GL_INT")
           ",\t"
           (code "GL_INT_VEC2")
           ",\t"
           (code "GL_INT_VEC3")
           ",\t"
           (code "GL_INT_VEC4")
           ",\t"
           (code "GL_BOOL")
           ",\t"
           (code "GL_BOOL_VEC2")
           ",\t"
           (code "GL_BOOL_VEC3")
           ",\t"
           (code "GL_BOOL_VEC4")
           ",\t"
           (code "GL_FLOAT_MAT2")
           ",\t"
           (code "GL_FLOAT_MAT3")
           ",\t"
           (code "GL_FLOAT_MAT4")
           ",\t"
           (code "GL_FLOAT_MAT2x3")
           ",\t"
           (code "GL_FLOAT_MAT2x4")
           ",\t"
           (code "GL_FLOAT_MAT3x2")
           ",\t"
           (code "GL_FLOAT_MAT3x4")
           ",\t"
           (code "GL_FLOAT_MAT4x2")
           ",\t"
           (code "GL_FLOAT_MAT4x3")
           ",\t"
           (code "GL_SAMPLER_1D")
           ",\t"
           (code "GL_SAMPLER_2D")
           ",\t"
           (code "GL_SAMPLER_3D")
           ",\t"
           (code "GL_SAMPLER_CUBE")
           ",\t"
           (code "GL_SAMPLER_1D_SHADOW")
           ", or\t"
           (code "GL_SAMPLER_2D_SHADOW")
           "
may be returned.")
     (para "If one or more elements of an array are active, the name
\tof the array is returned in "
           (var "name")
           ", the
\ttype is returned in "
           (var "type")
           ", and the\t"
           (var "size")
           " parameter returns the highest array
\telement index used, plus one, as determined by the compiler
\tand/or linker. Only one active uniform variable will be reported
\tfor a uniform array.")
     (para "Uniform variables that are declared as structures or
\tarrays of structures will not be returned directly by this
\tfunction. Instead, each of these uniform variables will be
\treduced to its fundamental components containing the
\t\".\" and \"[]\" operators such that each of the
\tnames is valid as an argument to\t"
           (code "glGetUniformLocation")
           ".
\tEach of these reduced uniform variables is counted as one active
\tuniform variable and is assigned an index. A valid name cannot
\tbe a structure, an array of structures, or a subcomponent of a
\tvector or matrix.")
     (para "The size of the uniform variable will be returned in\t"
           (var "size")
           ". Uniform variables other than arrays
\twill have a size of 1. Structures and arrays of structures will
\tbe reduced as described earlier, such that each of the names
\treturned will be a data type in the earlier list. If this
\treduction results in an array, the size returned will be as
\tdescribed for uniform arrays; otherwise, the size returned will
\tbe 1.")
     (para "The list of active uniform variables may include both
\tbuilt-in uniform variables (which begin with the prefix
\t\"gl_\") as well as user-defined uniform variable
\tnames.")
     (para "This function will return as much information as it can
\tabout the specified active uniform variable. If no information
\tis available, "
           (var "length")
           " will be 0, and\t"
           (var "name")
           " will be an empty string. This
\tsituation could occur if this function is called after a link
\toperation that failed. If an error occurs, the return values\t"
           (var "length")
           ", "
           (var "size")
           ",\t"
           (var "type")
           ", and "
           (var "name")
           "
will be unmodified.")
     (heading "Errors")
     (para (code "GL_INVALID_VALUE")
           " is generated if\t"
           (var "program")
           " is not a value generated by
\tOpenGL.")
     (para (code "GL_INVALID_OPERATION")
           " is generated if\t"
           (var "program")
           " is not a program object.")
     (para (code "GL_INVALID_VALUE")
           " is generated if\t"
           (var "index")
           " is greater than or equal to the
\tnumber of active uniform variables in\t"
           (var "program")
           ".")
     (para (code "GL_INVALID_OPERATION")
           " is generated if\t"
           (code "glGetActiveUniform")
           " is executed between the
\texecution of\t"
           (code "glBegin")
           "
and the corresponding execution of\t"
           (code "glEnd")
           ".")
     (para (code "GL_INVALID_VALUE")
           " is generated if\t"
           (var "bufSize")
           " is less than 0.")))

(define-gl-procedure
  glGetAttachedShaders
  "glGetAttachedShaders"
  (funcsynopsis
    (funcprototype
      (funcdef
        "void "
        (function "glGetAttachedShaders"))
      (paramdef "GLuint " (parameter "program"))
      (paramdef "GLsizei " (parameter "maxCount"))
      (paramdef "GLsizei *" (parameter "count"))
      (paramdef "GLuint *" (parameter "shaders"))))
  '(*fragment*
     (heading
       "Returns the handles of the shader objects attached to a program object")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "program")))
                   (para "Specifies the program object to be
\t\t    queried."))
            (entry (% (heading (var "maxCount")))
                   (para "Specifies the size of the array for storing
\t\t    the returned object names."))
            (entry (% (heading (var "count")))
                   (para "Returns the number of names actually returned
\t\t    in "
                         (var "objects")
                         "."))
            (entry (% (heading (var "shaders")))
                   (para "Specifies an array that is used to return the
\t\t    names of attached shader objects.")))
     (heading "Description")
     (para (code "glGetAttachedShaders")
           " returns the
\tnames of the shader objects attached to\t"
           (var "program")
           ". The names of shader objects that
\tare attached to "
           (var "program")
           " will be returned
\tin "
           (var "shaders.")
           " The actual number of shader
\tnames written into "
           (var "shaders")
           " is returned in\t"
           (var "count.")
           " If no shader objects are attached
\tto "
           (var "program")
           ", "
           (var "count")
           "
is set to 0. The maximum number of shader names that may be
\treturned in "
           (var "shaders")
           " is specified by\t"
           (var "maxCount")
           ". ")
     (para "If the number of names actually returned is not required
\t(for instance, if it has just been obtained by calling\t"
           (code "glGetProgram")
           "),
\ta value of "
           (code "NULL")
           " may be passed for count. If
\tno shader objects are attached to\t"
           (var "program")
           ", a value of 0 will be returned in\t"
           (var "count")
           ". The actual number of attached
\tshaders can be obtained by calling\t"
           (code "glGetProgram")
           "
with the value "
           (code "GL_ATTACHED_SHADERS")
           ".")
     (heading "Errors")
     (para (code "GL_INVALID_VALUE")
           " is generated if\t"
           (var "program")
           " is not a value generated by
\tOpenGL.")
     (para (code "GL_INVALID_OPERATION")
           " is generated if\t"
           (var "program")
           " is not a program object.")
     (para (code "GL_INVALID_VALUE")
           " is generated if\t"
           (var "maxCount")
           " is less than 0.")
     (para (code "GL_INVALID_OPERATION")
           " is generated if\t"
           (code "glGetAttachedShaders")
           "
is executed between the execution of\t"
           (code "glBegin")
           "
and the corresponding execution of\t"
           (code "glEnd")
           ".")))

(define-gl-procedure
  glGetAttribLocation
  "glGetAttribLocation"
  (funcsynopsis
    (funcprototype
      (funcdef
        "GLint "
        (function "glGetAttribLocation"))
      (paramdef "GLuint " (parameter "program"))
      (paramdef "const GLchar *" (parameter "name"))))
  '(*fragment*
     (heading
       "Returns the location of an attribute variable")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "program")))
                   (para "Specifies the program object to be
\t\t    queried."))
            (entry (% (heading (var "name")))
                   (para "Points to a null terminated string containing
\t\t    the name of the attribute variable whose location is
\t\t    to be queried.")))
     (heading "Description")
     (para (code "glGetAttribLocation")
           " queries the
\tpreviously linked program object specified by\t"
           (var "program")
           " for the attribute variable
\tspecified by "
           (var "name")
           " and returns the index
\tof the generic vertex attribute that is bound to that attribute
\tvariable. If "
           (var "name")
           " is a matrix attribute
\tvariable, the index of the first column of the matrix is
\treturned. If the named attribute variable is not an active
\tattribute in the specified program object or if\t"
           (var "name")
           " starts with the reserved prefix
\t\"gl_\", a value of -1 is returned.")
     (para "The association between an attribute variable name and a
\tgeneric attribute index can be specified at any time by calling\t"
           (code "glBindAttribLocation")
           ".
\tAttribute bindings do not go into effect until\t"
           (code "glLinkProgram")
           "
is called. After a program object has been linked successfully,
\tthe index values for attribute variables remain fixed until the
\tnext link command occurs. The attribute values can only be
\tqueried after a link if the link was successful.\t"
           (code "glGetAttribLocation")
           " returns the binding
\tthat actually went into effect the last time\t"
           (code "glLinkProgram")
           "
was called for the specified program object. Attribute bindings
\tthat have been specified since the last link operation are not
\treturned by "
           (code "glGetAttribLocation")
           ".")
     (heading "Errors")
     (para (code "GL_INVALID_OPERATION")
           " is generated if\t"
           (var "program")
           " is not a value generated by
\tOpenGL.")
     (para (code "GL_INVALID_OPERATION")
           " is generated if\t"
           (var "program")
           " is not a program object.")
     (para (code "GL_INVALID_OPERATION")
           " is generated if\t"
           (var "program")
           " has not been successfully
\tlinked.")
     (para (code "GL_INVALID_OPERATION")
           " is generated if\t"
           (code "glGetAttribLocation")
           " is executed between the
\texecution of\t"
           (code "glBegin")
           "
and the corresponding execution of\t"
           (code "glEnd")
           ".")))

(define-gl-procedure
  glGetBufferParameteriv
  "glGetBufferParameteriv"
  (funcsynopsis
    (funcprototype
      (funcdef
        "void "
        (function "glGetBufferParameteriv"))
      (paramdef "GLenum " (parameter "target"))
      (paramdef "GLenum " (parameter "value"))
      (paramdef "GLint * " (parameter "data"))))
  '(*fragment*
     (heading "return parameters of a buffer object")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "target")))
                   (para "
Specifies the target buffer object.
                    The symbolic constant must be "
                         (code "GL_ARRAY_BUFFER")
                         ", "
                         (code "GL_ELEMENT_ARRAY_BUFFER")
                         ", "
                         (code "GL_PIXEL_PACK_BUFFER")
                         ", or "
                         (code "GL_PIXEL_UNPACK_BUFFER")
                         ". "))
            (entry (% (heading (var "value")))
                   (para "
Specifies the symbolic name of a buffer object parameter.
                    Accepted values are "
                         (code "GL_BUFFER_ACCESS")
                         ", "
                         (code "GL_BUFFER_MAPPED")
                         ", "
                         (code "GL_BUFFER_SIZE")
                         ", or "
                         (code "GL_BUFFER_USAGE")
                         ". "))
            (entry (% (heading (var "data")))
                   (para "
Returns the requested parameter. ")))
     (heading "Description")
     (para (code "glGetBufferParameteriv")
           " returns in "
           (var "data")
           " a selected parameter of the buffer object
            specified by "
           (var "target")
           ". ")
     (para (var "value")
           " names a specific buffer object parameter, as follows: ")
     (table (% (formatter (asis)))
            (entry (% (heading (code "GL_BUFFER_ACCESS")))
                   (para (var "params")
                         " returns the access policy set while mapping the buffer object.  
                        The initial value is "
                         (code "GL_READ_WRITE")
                         ". "))
            (entry (% (heading (code "GL_BUFFER_MAPPED")))
                   (para (var "params")
                         " returns a flag indicating whether the buffer object is currently 
                        mapped. The initial value is "
                         (code "GL_FALSE")
                         ". "))
            (entry (% (heading (code "GL_BUFFER_SIZE")))
                   (para (var "params")
                         " returns the size of the buffer object, measured in bytes.  
                        The initial value is 0. "))
            (entry (% (heading (code "GL_BUFFER_USAGE")))
                   (para (var "params")
                         " returns the buffer object's usage pattern.  The initial value is "
                         (code "GL_STATIC_DRAW")
                         ". ")))
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "target")
           " or "
           (var "value")
           " is not an
            accepted value. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if the reserved buffer object name 0 is bound to "
           (var "target")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glGetBufferParameteriv")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glGetBufferPointerv
  "glGetBufferPointerv"
  (funcsynopsis
    (funcprototype
      (funcdef
        "void "
        (function "glGetBufferPointerv"))
      (paramdef "GLenum " (parameter "target"))
      (paramdef "GLenum " (parameter "pname"))
      (paramdef "GLvoid ** " (parameter "params"))))
  '(*fragment*
     (heading
       "return the pointer to a mapped buffer object's data store")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "target")))
                   (para "
Specifies the target buffer object.
                    The symbolic constant must be "
                         (code "GL_ARRAY_BUFFER")
                         ", "
                         (code "GL_ELEMENT_ARRAY_BUFFER")
                         ", "
                         (code "GL_PIXEL_PACK_BUFFER")
                         ", or "
                         (code "GL_PIXEL_UNPACK_BUFFER")
                         ". "))
            (entry (% (heading (var "pname")))
                   (para "
Specifies the pointer to be returned.  The symbolic constant must be "
                         (code "GL_BUFFER_MAP_POINTER")
                         ". "))
            (entry (% (heading (var "params")))
                   (para "
Returns the pointer value specified by "
                         (var "pname")
                         ". ")))
     (heading "Description")
     (para (code "glGetBufferPointerv")
           " returns pointer information. "
           (var "pname")
           " is a symbolic constant
            indicating the pointer to be returned, which must be "
           (code "GL_BUFFER_MAP_POINTER")
           ", the pointer
            to which the buffer object's data store is mapped.  If the data store is not currently mapped, "
           (code "NULL")
           " is returned. "
           (var "params")
           " is a pointer to a location in which to place the returned pointer value. ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "target")
           " or "
           (var "pname")
           " is not an
            accepted value. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if the reserved buffer object name 0 is bound to "
           (var "target")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glGetBufferPointerv")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glGetBufferSubData
  "glGetBufferSubData"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glGetBufferSubData"))
      (paramdef "GLenum " (parameter "target"))
      (paramdef "GLintptr " (parameter "offset"))
      (paramdef "GLsizeiptr " (parameter "size"))
      (paramdef "GLvoid * " (parameter "data"))))
  '(*fragment*
     (heading
       "returns a subset of a buffer object's data store")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "target")))
                   (para "
Specifies the target buffer object.
                    The symbolic constant must be "
                         (code "GL_ARRAY_BUFFER")
                         ", "
                         (code "GL_ELEMENT_ARRAY_BUFFER")
                         ", "
                         (code "GL_PIXEL_PACK_BUFFER")
                         ", or "
                         (code "GL_PIXEL_UNPACK_BUFFER")
                         ". "))
            (entry (% (heading (var "offset")))
                   (para "
Specifies the offset into the buffer object's data store from which data will be returned,
                    measured in bytes. "))
            (entry (% (heading (var "size")))
                   (para "
Specifies the size in bytes of the data store region being returned. "))
            (entry (% (heading (var "data")))
                   (para "
Specifies a pointer to the location where buffer object data is returned. ")))
     (heading "Description")
     (para (code "glGetBufferSubData")
           " returns some or all of the data from the buffer object currently 
            bound to "
           (var "target")
           ". Data starting at byte offset "
           (var "offset")
           " and
            extending for "
           (var "size")
           " bytes is copied from the data store to the memory pointed to by "
           (var "data")
           ". An error is thrown if the buffer object is currently mapped, or if "
           (var "offset")
           " and "
           (var "size")
           " together define a range beyond the bounds 
            of the buffer object's data store. ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "target")
           " is not "
           (code "GL_ARRAY_BUFFER")
           ", "
           (code "GL_ELEMENT_ARRAY_BUFFER")
           ", "
           (code "GL_PIXEL_PACK_BUFFER")
           ", or "
           (code "GL_PIXEL_UNPACK_BUFFER")
           ". ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "offset")
           " or "
           (var "size")
           " is negative, or if together they define a region of memory
            that extends beyond the buffer object's allocated data store. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if the reserved buffer object name 0 is bound to "
           (var "target")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if the buffer object being queried is mapped. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glGetBufferSubData")
           "
is executed between the execution of "
           (code "glBegin")
           " and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glGetClipPlane
  "glGetClipPlane"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glGetClipPlane"))
      (paramdef "GLenum " (parameter "plane"))
      (paramdef "GLdouble * " (parameter "equation"))))
  '(*fragment*
     (heading
       "return the coefficients of the specified clipping plane")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "plane")))
                   (para "
Specifies a clipping plane.
                    The number of clipping planes depends on the implementation,
                    but at least six clipping planes are supported.
                    They are identified by symbolic names of the form "
                         (code "GL_CLIP_PLANE")
                         (math (var "i"))
                         "
where i ranges from 0 to the value of "
                         (code "GL_MAX_CLIP_PLANES")
                         " - 1. "))
            (entry (% (heading (var "equation")))
                   (para "
Returns four double-precision values that are the coefficients of the plane equation of "
                         (var "plane")
                         " in eye coordinates.
                    The initial value is (0, 0, 0, 0). ")))
     (heading "Description")
     (para (code "glGetClipPlane")
           " returns in "
           (var "equation")
           " the four coefficients of the plane equation
            for "
           (var "plane")
           ". ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "plane")
           " is not an accepted value. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glGetClipPlane")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glGetColorTableParameter
  "glGetColorTableParameter"
  (funcsynopsis
    (funcprototype
      (funcdef
        "void "
        (function "glGetColorTableParameterfv"))
      (paramdef "GLenum " (parameter "target"))
      (paramdef "GLenum " (parameter "pname"))
      (paramdef "GLfloat * " (parameter "params"))))
  '(*fragment*
     (heading "get color lookup table parameters")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "target")))
                   (para "
The target color table.
                    Must be "
                         (code "GL_COLOR_TABLE")
                         ", "
                         (code "GL_POST_CONVOLUTION_COLOR_TABLE")
                         ", "
                         (code "GL_POST_COLOR_MATRIX_COLOR_TABLE")
                         ", "
                         (code "GL_PROXY_COLOR_TABLE")
                         ", "
                         (code "GL_PROXY_POST_CONVOLUTION_COLOR_TABLE")
                         ", or "
                         (code "GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE")
                         ". "))
            (entry (% (heading (var "pname")))
                   (para "
The symbolic name of a color lookup table parameter.
                    Must be one of "
                         (code "GL_COLOR_TABLE_BIAS")
                         ", "
                         (code "GL_COLOR_TABLE_SCALE")
                         ", "
                         (code "GL_COLOR_TABLE_FORMAT")
                         ", "
                         (code "GL_COLOR_TABLE_WIDTH")
                         ", "
                         (code "GL_COLOR_TABLE_RED_SIZE")
                         ", "
                         (code "GL_COLOR_TABLE_GREEN_SIZE")
                         ", "
                         (code "GL_COLOR_TABLE_BLUE_SIZE")
                         ", "
                         (code "GL_COLOR_TABLE_ALPHA_SIZE")
                         ", "
                         (code "GL_COLOR_TABLE_LUMINANCE_SIZE")
                         ", or "
                         (code "GL_COLOR_TABLE_INTENSITY_SIZE")
                         ". "))
            (entry (% (heading (var "params")))
                   (para "
A pointer to an array where the values of the parameter will be stored. ")))
     (heading "Description")
     (para "
Returns parameters specific to color table "
           (var "target")
           ". ")
     (para "
When "
           (var "pname")
           " is set to "
           (code "GL_COLOR_TABLE_SCALE")
           " or "
           (code "GL_COLOR_TABLE_BIAS")
           ", "
           (code "glGetColorTableParameter")
           " returns the color
            table scale or bias parameters for the table specified by "
           (var "target")
           ".
            For these queries, "
           (var "target")
           " must be set to "
           (code "GL_COLOR_TABLE")
           ", "
           (code "GL_POST_CONVOLUTION_COLOR_TABLE")
           ",
            or "
           (code "GL_POST_COLOR_MATRIX_COLOR_TABLE")
           " and "
           (var "params")
           " points to an array of four elements, which receive
            the scale or bias factors for red, green, blue, and alpha, in that order. ")
     (para (code "glGetColorTableParameter")
           " can also be used to retrieve the format and size parameters
            for a color table. For these queries, set "
           (var "target")
           " to either the
            color table target or the proxy color table target.
            The format and size parameters are set by "
           (code "glColorTable")
           ". ")
     (para "
The following table lists the format and size parameters that may
            be queried.
            For each symbolic constant listed below for "
           (var "pname")
           ", "
           (var "params")
           " must point to an array of the
            given length and receive the values indicated. ")
     (para)
     (table (% (formatter (asis)))
            (entry (% (heading (strong "Parameter")))
                   (para (strong "N") ", " (strong "Meaning")))
            (entry (% (heading (code "GL_COLOR_TABLE_FORMAT")))
                   (para "
1 "
                         ", "
                         "
Internal format (e.g., "
                         (code "GL_RGBA")
                         ") "))
            (entry (% (heading (code "GL_COLOR_TABLE_WIDTH")))
                   (para "
1 " ", " "
Number of elements in table "))
            (entry (% (heading (code "GL_COLOR_TABLE_RED_SIZE")))
                   (para "
1 "
                         ", "
                         "
Size of red component, in bits "))
            (entry (% (heading (code "GL_COLOR_TABLE_GREEN_SIZE")))
                   (para "
1 " ", " "
Size of green component "))
            (entry (% (heading (code "GL_COLOR_TABLE_BLUE_SIZE")))
                   (para "
1 " ", " "
Size of blue component "))
            (entry (% (heading (code "GL_COLOR_TABLE_ALPHA_SIZE")))
                   (para "
1 " ", " "
Size of alpha component "))
            (entry (% (heading (code "GL_COLOR_TABLE_LUMINANCE_SIZE")))
                   (para "
1 " ", " "
Size of luminance component "))
            (entry (% (heading (code "GL_COLOR_TABLE_INTENSITY_SIZE")))
                   (para "
1 " ", " "
Size of intensity component ")))
     (para)
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "target")
           " or "
           (var "pname")
           " is not
            an acceptable value. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glGetColorTableParameter")
           " is executed
            between the execution of "
           (code "glBegin")
           " and the corresponding
            execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glGetColorTable
  "glGetColorTable"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glGetColorTable"))
      (paramdef "GLenum " (parameter "target"))
      (paramdef "GLenum " (parameter "format"))
      (paramdef "GLenum " (parameter "type"))
      (paramdef "GLvoid * " (parameter "table"))))
  '(*fragment*
     (heading
       "retrieve contents of a color lookup table")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "target")))
                   (para "
Must be "
                         (code "GL_COLOR_TABLE")
                         ", "
                         (code "GL_POST_CONVOLUTION_COLOR_TABLE")
                         ",
                    or "
                         (code "GL_POST_COLOR_MATRIX_COLOR_TABLE")
                         ". "))
            (entry (% (heading (var "format")))
                   (para "
The format of the pixel data in "
                         (var "table")
                         ".
                    The possible values are "
                         (code "GL_RED")
                         ", "
                         (code "GL_GREEN")
                         ", "
                         (code "GL_BLUE")
                         ", "
                         (code "GL_ALPHA")
                         ", "
                         (code "GL_LUMINANCE")
                         ", "
                         (code "GL_LUMINANCE_ALPHA")
                         ", "
                         (code "GL_RGB")
                         ", "
                         (code "GL_BGR")
                         ", "
                         (code "GL_RGBA")
                         ", and "
                         (code "GL_BGRA")
                         ". "))
            (entry (% (heading (var "type")))
                   (para "
The type of the pixel data in "
                         (var "table")
                         ".
                    Symbolic constants "
                         (code "GL_UNSIGNED_BYTE")
                         ", "
                         (code "GL_BYTE")
                         ", "
                         (code "GL_BITMAP")
                         ", "
                         (code "GL_UNSIGNED_SHORT")
                         ", "
                         (code "GL_SHORT")
                         ", "
                         (code "GL_UNSIGNED_INT")
                         ", "
                         (code "GL_INT")
                         ", "
                         (code "GL_FLOAT")
                         ", "
                         (code "GL_UNSIGNED_BYTE_3_3_2")
                         ", "
                         (code "GL_UNSIGNED_BYTE_2_3_3_REV")
                         ", "
                         (code "GL_UNSIGNED_SHORT_5_6_5")
                         ", "
                         (code "GL_UNSIGNED_SHORT_5_6_5_REV")
                         ", "
                         (code "GL_UNSIGNED_SHORT_4_4_4_4")
                         ", "
                         (code "GL_UNSIGNED_SHORT_4_4_4_4_REV")
                         ", "
                         (code "GL_UNSIGNED_SHORT_5_5_5_1")
                         ", "
                         (code "GL_UNSIGNED_SHORT_1_5_5_5_REV")
                         ", "
                         (code "GL_UNSIGNED_INT_8_8_8_8")
                         ", "
                         (code "GL_UNSIGNED_INT_8_8_8_8_REV")
                         ", "
                         (code "GL_UNSIGNED_INT_10_10_10_2")
                         ", and "
                         (code "GL_UNSIGNED_INT_2_10_10_10_REV")
                         "
are accepted. "))
            (entry (% (heading (var "table")))
                   (para "
Pointer to a one-dimensional array of pixel data containing the contents
                    of the color table. ")))
     (heading "Description")
     (para (code "glGetColorTable")
           " returns in "
           (var "table")
           " the contents of the color table specified
            by "
           (var "target")
           ". No pixel transfer operations are performed, but pixel
            storage modes that are applicable to "
           (code "glReadPixels")
           " are performed. ")
     (para "
If a non-zero named buffer object is bound to the "
           (code "GL_PIXEL_PACK_BUFFER")
           " target 
            (see "
           (code "glBindBuffer")
           ") while a histogram table is
            requested, "
           (var "table")
           " is treated as a byte offset into the buffer object's data store. ")
     (para "
Color components that are requested in
            the specified "
           (var "format")
           ", but which are not included in the internal
            format of the color lookup table, are returned as zero.  The
            assignments of internal color components to the components
            requested by "
           (var "format")
           " are ")
     (table (% (formatter (asis)))
            (entry (% (heading (strong "Internal Component")))
                   (para (strong "Resulting Component")))
            (entry (% (heading "
Red ")) (para "
Red "))
            (entry (% (heading "
Green ")) (para "
Green "))
            (entry (% (heading "
Blue ")) (para "
Blue "))
            (entry (% (heading "
Alpha ")) (para "
Alpha "))
            (entry (% (heading "
Luminance "))
                   (para "
Red "))
            (entry (% (heading "
Intensity "))
                   (para "
Red ")))
     (para)
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "target")
           " is not one of the allowable
            values. ")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "format")
           " is not one of the allowable
            values. ")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "type")
           " is not one of the allowable
            values. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (var "type")
           " is one of "
           (code "GL_UNSIGNED_BYTE_3_3_2")
           ", "
           (code "GL_UNSIGNED_BYTE_2_3_3_REV")
           ", "
           (code "GL_UNSIGNED_SHORT_5_6_5")
           ", or "
           (code "GL_UNSIGNED_SHORT_5_6_5_REV")
           "
and "
           (var "format")
           " is not "
           (code "GL_RGB")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (var "type")
           " is one of "
           (code "GL_UNSIGNED_SHORT_4_4_4_4")
           ", "
           (code "GL_UNSIGNED_SHORT_4_4_4_4_REV")
           ", "
           (code "GL_UNSIGNED_SHORT_5_5_5_1")
           ", "
           (code "GL_UNSIGNED_SHORT_1_5_5_5_REV")
           ", "
           (code "GL_UNSIGNED_INT_8_8_8_8")
           ", "
           (code "GL_UNSIGNED_INT_8_8_8_8_REV")
           ", "
           (code "GL_UNSIGNED_INT_10_10_10_2")
           ", or "
           (code "GL_UNSIGNED_INT_2_10_10_10_REV")
           "
and "
           (var "format")
           " is neither "
           (code "GL_RGBA")
           " nor "
           (code "GL_BGRA")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_PACK_BUFFER")
           " target and the buffer object's data store is currently mapped. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_PACK_BUFFER")
           " target and the data would be packed to the buffer 
            object such that the memory writes required would exceed the data store size. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_PACK_BUFFER")
           " target and "
           (var "table")
           " is not evenly divisible 
            into the number of bytes needed to store in memory a datum indicated by "
           (var "type")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glGetColorTable")
           " is executed
            between the execution of "
           (code "glBegin")
           " and the corresponding
            execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glGetCompressedTexImage
  "glGetCompressedTexImage"
  (funcsynopsis
    (funcprototype
      (funcdef
        "void "
        (function "glGetCompressedTexImage"))
      (paramdef "GLenum " (parameter "target"))
      (paramdef "GLint " (parameter "lod"))
      (paramdef "GLvoid * " (parameter "img"))))
  '(*fragment*
     (heading "return a compressed texture image")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "target")))
                   (para "
Specifies which texture is to be obtained. "
                         (code "GL_TEXTURE_1D")
                         ", "
                         (code "GL_TEXTURE_2D")
                         ", and "
                         (code "GL_TEXTURE_3D")
                         (code "GL_TEXTURE_CUBE_MAP_POSITIVE_X")
                         ", "
                         (code "GL_TEXTURE_CUBE_MAP_NEGATIVE_X")
                         ", "
                         (code "GL_TEXTURE_CUBE_MAP_POSITIVE_Y")
                         ", "
                         (code "GL_TEXTURE_CUBE_MAP_NEGATIVE_Y")
                         ", "
                         (code "GL_TEXTURE_CUBE_MAP_POSITIVE_Z")
                         ", and "
                         (code "GL_TEXTURE_CUBE_MAP_NEGATIVE_Z")
                         "
are accepted. "))
            (entry (% (heading (var "lod")))
                   (para "
Specifies the level-of-detail number of the desired image.
                    Level 0 is the base image level.
                    Level "
                         (math (var "n"))
                         "
is the "
                         (math (var "n"))
                         "th
                    mipmap reduction image. "))
            (entry (% (heading (var "img")))
                   (para "
Returns the compressed texture image. ")))
     (heading "Description")
     (para (code "glGetCompressedTexImage")
           " returns the compressed texture image associated with "
           (var "target")
           " and "
           (var "lod")
           "
into "
           (var "img")
           ". "
           (var "img")
           " should be an array of "
           (code "GL_TEXTURE_COMPRESSED_IMAGE_SIZE")
           " bytes. "
           (var "target")
           " specifies whether the desired texture image was one specified by "
           (code "glTexImage1D")
           " ("
           (code "GL_TEXTURE_1D")
           "), "
           (code "glTexImage2D")
           " ("
           (code "GL_TEXTURE_2D")
           " or any of "
           (code "GL_TEXTURE_CUBE_MAP_*")
           "), or "
           (code "glTexImage3D")
           " ("
           (code "GL_TEXTURE_3D")
           "). "
           (var "lod")
           " specifies the level-of-detail number of the desired image. ")
     (para "
If a non-zero named buffer object is bound to the "
           (code "GL_PIXEL_PACK_BUFFER")
           " target 
            (see "
           (code "glBindBuffer")
           ") while a texture image is
            requested, "
           (var "img")
           " is treated as a byte offset into the buffer object's data store. ")
     (para "
To minimize errors, first verify that the texture is compressed by calling "
           (code "glGetTexLevelParameter")
           " with argument "
           (code "GL_TEXTURE_COMPRESSED")
           ".  If
            the texture is compressed, then determine the amount of memory required to
            store the compressed texture by calling "
           (code "glGetTexLevelParameter")
           " with
            argument "
           (code "GL_TEXTURE_COMPRESSED_IMAGE_SIZE")
           ".  Finally, retrieve the
            internal format of the texture by calling "
           (code "glGetTexLevelParameter")
           " with
            argument "
           (code "GL_TEXTURE_INTERNAL_FORMAT")
           ".
            To store the texture for later use, associate the internal format and size
            with the retrieved texture image.  These data can be used by the respective
            texture or subtexture loading routine used for loading "
           (var "target")
           " textures. ")
     (heading "Errors")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "lod")
           " is less than zero or greater
            than the maximum number of LODs permitted by the implementation. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glGetCompressedTexImage")
           " is used to retrieve a
            texture that is in an uncompressed internal format. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_PACK_BUFFER")
           " target and the buffer object's data store is currently mapped. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_PACK_BUFFER")
           " target and the data would be packed to the buffer 
            object such that the memory writes required would exceed the data store size. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glGetCompressedTexImage")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glGetConvolutionFilter
  "glGetConvolutionFilter"
  (funcsynopsis
    (funcprototype
      (funcdef
        "void "
        (function "glGetConvolutionFilter"))
      (paramdef "GLenum " (parameter "target"))
      (paramdef "GLenum " (parameter "format"))
      (paramdef "GLenum " (parameter "type"))
      (paramdef "GLvoid * " (parameter "image"))))
  '(*fragment*
     (heading
       "get current 1D or 2D convolution filter kernel")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "target")))
                   (para "
The filter to be retrieved.
                    Must be one of "
                         (code "GL_CONVOLUTION_1D")
                         " or "
                         (code "GL_CONVOLUTION_2D")
                         ". "))
            (entry (% (heading (var "format")))
                   (para "
Format of the output image.
                    Must be one of "
                         (code "GL_RED")
                         ", "
                         (code "GL_GREEN")
                         ", "
                         (code "GL_BLUE")
                         ", "
                         (code "GL_ALPHA")
                         ", "
                         (code "GL_RGB")
                         ", "
                         (code "GL_BGR")
                         ", "
                         (code "GL_RGBA")
                         ", "
                         (code "GL_BGRA")
                         ", "
                         (code "GL_LUMINANCE")
                         ", or "
                         (code "GL_LUMINANCE_ALPHA")
                         ". "))
            (entry (% (heading (var "type")))
                   (para "
Data type of components in the output image.
                    Symbolic constants "
                         (code "GL_UNSIGNED_BYTE")
                         ", "
                         (code "GL_BYTE")
                         ", "
                         (code "GL_BITMAP")
                         ", "
                         (code "GL_UNSIGNED_SHORT")
                         ", "
                         (code "GL_SHORT")
                         ", "
                         (code "GL_UNSIGNED_INT")
                         ", "
                         (code "GL_INT")
                         ", "
                         (code "GL_FLOAT")
                         ", "
                         (code "GL_UNSIGNED_BYTE_3_3_2")
                         ", "
                         (code "GL_UNSIGNED_BYTE_2_3_3_REV")
                         ", "
                         (code "GL_UNSIGNED_SHORT_5_6_5")
                         ", "
                         (code "GL_UNSIGNED_SHORT_5_6_5_REV")
                         ", "
                         (code "GL_UNSIGNED_SHORT_4_4_4_4")
                         ", "
                         (code "GL_UNSIGNED_SHORT_4_4_4_4_REV")
                         ", "
                         (code "GL_UNSIGNED_SHORT_5_5_5_1")
                         ", "
                         (code "GL_UNSIGNED_SHORT_1_5_5_5_REV")
                         ", "
                         (code "GL_UNSIGNED_INT_8_8_8_8")
                         ", "
                         (code "GL_UNSIGNED_INT_8_8_8_8_REV")
                         ", "
                         (code "GL_UNSIGNED_INT_10_10_10_2")
                         ", and "
                         (code "GL_UNSIGNED_INT_2_10_10_10_REV")
                         "
are accepted. "))
            (entry (% (heading (var "image")))
                   (para "
Pointer to storage for the output image. ")))
     (heading "Description")
     (para (code "glGetConvolutionFilter")
           " returns the current 1D or 2D convolution filter kernel as an image.
            The one- or two-dimensional image is placed in "
           (var "image")
           " according to the
            specifications in "
           (var "format")
           " and "
           (var "type")
           ".
            No pixel transfer operations are performed on this image, but the relevant
            pixel storage modes are applied. ")
     (para "
If a non-zero named buffer object is bound to the "
           (code "GL_PIXEL_PACK_BUFFER")
           " target 
            (see "
           (code "glBindBuffer")
           ") while a convolution filter is
            requested, "
           (var "image")
           " is treated as a byte offset into the buffer object's data store. ")
     (para "
Color components that are present in "
           (var "format")
           " but not included in the
            internal format of the filter are returned as zero.
            The assignments of internal color components to the components of "
           (var "format")
           "
are as follows. ")
     (table (% (formatter (asis)))
            (entry (% (heading (strong "Internal Component")))
                   (para (strong "Resulting Component")))
            (entry (% (heading "
Red ")) (para "
Red "))
            (entry (% (heading "
Green ")) (para "
Green "))
            (entry (% (heading "
Blue ")) (para "
Blue "))
            (entry (% (heading "
Alpha ")) (para "
Alpha "))
            (entry (% (heading "
Luminance "))
                   (para "
Red "))
            (entry (% (heading "
Intensity "))
                   (para "
Red ")))
     (para)
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "target")
           " is not one of the allowable
            values. ")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "format")
           " is not one of the allowable
            values. ")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "type")
           " is not one of the allowable
            values. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (var "type")
           " is one of "
           (code "GL_UNSIGNED_BYTE_3_3_2")
           ", "
           (code "GL_UNSIGNED_BYTE_2_3_3_REV")
           ", "
           (code "GL_UNSIGNED_SHORT_5_6_5")
           ", or "
           (code "GL_UNSIGNED_SHORT_5_6_5_REV")
           "
and "
           (var "format")
           " is not "
           (code "GL_RGB")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (var "type")
           " is one of "
           (code "GL_UNSIGNED_SHORT_4_4_4_4")
           ", "
           (code "GL_UNSIGNED_SHORT_4_4_4_4_REV")
           ", "
           (code "GL_UNSIGNED_SHORT_5_5_5_1")
           ", "
           (code "GL_UNSIGNED_SHORT_1_5_5_5_REV")
           ", "
           (code "GL_UNSIGNED_INT_8_8_8_8")
           ", "
           (code "GL_UNSIGNED_INT_8_8_8_8_REV")
           ", "
           (code "GL_UNSIGNED_INT_10_10_10_2")
           ", or "
           (code "GL_UNSIGNED_INT_2_10_10_10_REV")
           "
and "
           (var "format")
           " is neither "
           (code "GL_RGBA")
           " nor "
           (code "GL_BGRA")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_PACK_BUFFER")
           " target and the buffer object's data store is currently mapped. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_PACK_BUFFER")
           " target and the data would be packed to the buffer 
            object such that the memory writes required would exceed the data store size. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_PACK_BUFFER")
           " target and "
           (var "image")
           " is not evenly divisible 
            into the number of bytes needed to store in memory a datum indicated by "
           (var "type")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glGetConvolutionFilter")
           " is executed
            between the execution of "
           (code "glBegin")
           " and the corresponding
            execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glGetConvolutionParameter
  "glGetConvolutionParameter"
  (funcsynopsis
    (funcprototype
      (funcdef
        "void "
        (function "glGetConvolutionParameterfv"))
      (paramdef "GLenum " (parameter "target"))
      (paramdef "GLenum " (parameter "pname"))
      (paramdef "GLfloat * " (parameter "params"))))
  '(*fragment*
     (heading "get convolution parameters")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "target")))
                   (para "
The filter whose parameters are to be retrieved.
                    Must be one of "
                         (code "GL_CONVOLUTION_1D")
                         ", "
                         (code "GL_CONVOLUTION_2D")
                         ", or "
                         (code "GL_SEPARABLE_2D")
                         ". "))
            (entry (% (heading (var "pname")))
                   (para "
The parameter to be retrieved.
                    Must be one of "
                         (code "GL_CONVOLUTION_BORDER_MODE")
                         ", "
                         (code "GL_CONVOLUTION_BORDER_COLOR")
                         ", "
                         (code "GL_CONVOLUTION_FILTER_SCALE")
                         ", "
                         (code "GL_CONVOLUTION_FILTER_BIAS")
                         ", "
                         (code "GL_CONVOLUTION_FORMAT")
                         ", "
                         (code "GL_CONVOLUTION_WIDTH")
                         ", "
                         (code "GL_CONVOLUTION_HEIGHT")
                         ", "
                         (code "GL_MAX_CONVOLUTION_WIDTH")
                         ", or "
                         (code "GL_MAX_CONVOLUTION_HEIGHT")
                         ". "))
            (entry (% (heading (var "params")))
                   (para "
Pointer to storage for the parameters to be retrieved. ")))
     (heading "Description")
     (para (code "glGetConvolutionParameter")
           " retrieves convolution parameters. "
           (var "target")
           " determines which convolution filter is queried. "
           (var "pname")
           " determines which parameter is returned: ")
     (table (% (formatter (asis)))
            (entry (% (heading (code "GL_CONVOLUTION_BORDER_MODE")))
                   (para)
                   (para "
The convolution border mode.
                        See "
                         (code "glConvolutionParameter")
                         " for a list of border modes. "))
            (entry (% (heading (code "GL_CONVOLUTION_BORDER_COLOR")))
                   (para)
                   (para "
The current convolution border color. "
                         (var "params")
                         " must be a pointer to an array of four elements,
                        which will receive the red, green, blue, and alpha border colors. "))
            (entry (% (heading (code "GL_CONVOLUTION_FILTER_SCALE")))
                   (para)
                   (para "
The current filter scale factors. "
                         (var "params")
                         " must be a pointer to an array of four elements,
                        which will receive the red, green, blue, and alpha filter scale
                        factors in that order. "))
            (entry (% (heading (code "GL_CONVOLUTION_FILTER_BIAS")))
                   (para)
                   (para "
The current filter bias factors. "
                         (var "params")
                         " must be a pointer to an array of four elements,
                        which will receive the red, green, blue, and alpha filter bias
                        terms in that order. "))
            (entry (% (heading (code "GL_CONVOLUTION_FORMAT")))
                   (para)
                   (para "
The current internal format.
                        See "
                         (code "glConvolutionFilter1D")
                         ", "
                         (code "glConvolutionFilter2D")
                         ",
                        and "
                         (code "glSeparableFilter2D")
                         " for lists of allowable
                        formats. "))
            (entry (% (heading (code "GL_CONVOLUTION_WIDTH")))
                   (para)
                   (para "
The current filter image width. "))
            (entry (% (heading (code "GL_CONVOLUTION_HEIGHT")))
                   (para)
                   (para "
The current filter image height. "))
            (entry (% (heading (code "GL_MAX_CONVOLUTION_WIDTH")))
                   (para)
                   (para "
The maximum acceptable filter image width. "))
            (entry (% (heading (code "GL_MAX_CONVOLUTION_HEIGHT")))
                   (para)
                   (para "
The maximum acceptable filter image height. ")))
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "target")
           " is not one of the allowable
            values. ")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "pname")
           " is not one of the allowable
            values. ")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "target")
           " is "
           (code "GL_CONVOLUTION_1D")
           "
and "
           (var "pname")
           " is "
           (code "GL_CONVOLUTION_HEIGHT")
           " or "
           (code "GL_MAX_CONVOLUTION_HEIGHT")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glGetConvolutionParameter")
           " is executed
            between the execution of "
           (code "glBegin")
           " and the corresponding
            execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glGetError
  "glGetError"
  (funcsynopsis
    (funcprototype
      (funcdef "GLenum " (function "glGetError"))
      (paramdef (parameter "void"))))
  '(*fragment*
     (heading "return error information")
     (heading "Description")
     (para (code "glGetError")
           " returns the value of the error flag.
            Each detectable error is assigned a numeric code and symbolic name.
            When an error occurs,
            the error flag is set to the appropriate error code value.
            No other errors are recorded until "
           (code "glGetError")
           " is called,
            the error code is returned,
            and the flag is reset to "
           (code "GL_NO_ERROR")
           ".
            If a call to "
           (code "glGetError")
           " returns "
           (code "GL_NO_ERROR")
           ",
            there has been no detectable error since the last call to "
           (code "glGetError")
           ",
            or since the GL was initialized. ")
     (para "
To allow for distributed implementations,
            there may be several error flags.
            If any single error flag has recorded an error,
            the value of that flag is returned
            and that flag is reset to "
           (code "GL_NO_ERROR")
           "
when "
           (code "glGetError")
           " is called.
            If more than one flag has recorded an error, "
           (code "glGetError")
           " returns and clears an arbitrary error flag value.
            Thus, "
           (code "glGetError")
           " should always be called in a loop,
            until it returns "
           (code "GL_NO_ERROR")
           ",
            if all error flags are to be reset. ")
     (para "
Initially, all error flags are set to "
           (code "GL_NO_ERROR")
           ". ")
     (para "
The following errors are currently defined: ")
     (table (% (formatter (asis)))
            (entry (% (heading (code "GL_NO_ERROR")))
                   (para "
No error has been recorded.
                        The value of this symbolic constant is guaranteed to be 0. "))
            (entry (% (heading (code "GL_INVALID_ENUM")))
                   (para "
An unacceptable value is specified for an enumerated argument.
                        The offending command is ignored
                        and has no other side effect than to set the error flag. "))
            (entry (% (heading (code "GL_INVALID_VALUE")))
                   (para "
A numeric argument is out of range.
                        The offending command is ignored
                        and has no other side effect than to set the error flag. "))
            (entry (% (heading (code "GL_INVALID_OPERATION")))
                   (para "
The specified operation is not allowed in the current state.
                        The offending command is ignored
                        and has no other side effect than to set the error flag. "))
            (entry (% (heading (code "GL_STACK_OVERFLOW")))
                   (para "
This command would cause a stack overflow.
                        The offending command is ignored
                        and has no other side effect than to set the error flag. "))
            (entry (% (heading (code "GL_STACK_UNDERFLOW")))
                   (para "
This command would cause a stack underflow.
                        The offending command is ignored
                        and has no other side effect than to set the error flag. "))
            (entry (% (heading (code "GL_OUT_OF_MEMORY")))
                   (para "
There is not enough memory left to execute the command.
                        The state of the GL is undefined,
                        except for the state of the error flags,
                        after this error is recorded. "))
            (entry (% (heading (code "GL_TABLE_TOO_LARGE")))
                   (para "
The specified table exceeds the implementation's maximum supported table
                        size.  The offending command is ignored and has no other side effect
                        than to set the error flag. ")))
     (para "
When an error flag is set,
            results of a GL operation are undefined only if "
           (code "GL_OUT_OF_MEMORY")
           "
has occurred.
            In all other cases,
            the command generating the error is ignored and has no effect on the GL state
            or frame buffer contents.
            If the generating command returns a value, it returns 0.
            If "
           (code "glGetError")
           " itself generates an error, it returns 0. ")
     (heading "Errors")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glGetError")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ".
            In this case, "
           (code "glGetError")
           " returns 0. ")))

(define-gl-procedure
  glGetHistogramParameter
  "glGetHistogramParameter"
  (funcsynopsis
    (funcprototype
      (funcdef
        "void "
        (function "glGetHistogramParameterfv"))
      (paramdef "GLenum " (parameter "target"))
      (paramdef "GLenum " (parameter "pname"))
      (paramdef "GLfloat * " (parameter "params"))))
  '(*fragment*
     (heading "get histogram parameters")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "target")))
                   (para "
Must be one of "
                         (code "GL_HISTOGRAM")
                         " or "
                         (code "GL_PROXY_HISTOGRAM")
                         ". "))
            (entry (% (heading (var "pname")))
                   (para "
The name of the parameter to be retrieved.
                    Must be one of "
                         (code "GL_HISTOGRAM_WIDTH")
                         ", "
                         (code "GL_HISTOGRAM_FORMAT")
                         ", "
                         (code "GL_HISTOGRAM_RED_SIZE")
                         ", "
                         (code "GL_HISTOGRAM_GREEN_SIZE")
                         ", "
                         (code "GL_HISTOGRAM_BLUE_SIZE")
                         ", "
                         (code "GL_HISTOGRAM_ALPHA_SIZE")
                         ", "
                         (code "GL_HISTOGRAM_LUMINANCE_SIZE")
                         ", or "
                         (code "GL_HISTOGRAM_SINK")
                         ". "))
            (entry (% (heading (var "params")))
                   (para "
Pointer to storage for the returned values. ")))
     (heading "Description")
     (para (code "glGetHistogramParameter")
           " is used to query parameter values for the current histogram or for
            a proxy.  The histogram state information may be queried by calling "
           (code "glGetHistogramParameter")
           " with a "
           (var "target")
           " of "
           (code "GL_HISTOGRAM")
           " (to
            obtain information for the current histogram table) or "
           (code "GL_PROXY_HISTOGRAM")
           " (to obtain information from the most recent
            proxy request) and one of the following values for the "
           (var "pname")
           " argument: ")
     (para)
     (table (% (formatter (asis)))
            (entry (% (heading (strong "Parameter")))
                   (para (strong "Description")))
            (entry (% (heading (code "GL_HISTOGRAM_WIDTH")))
                   (para "
Histogram table width "))
            (entry (% (heading (code "GL_HISTOGRAM_FORMAT")))
                   (para "
Internal format "))
            (entry (% (heading (code "GL_HISTOGRAM_RED_SIZE")))
                   (para "
Red component counter size, in bits "))
            (entry (% (heading (code "GL_HISTOGRAM_GREEN_SIZE")))
                   (para "
Green component counter size, in bits "))
            (entry (% (heading (code "GL_HISTOGRAM_BLUE_SIZE")))
                   (para "
Blue component counter size, in bits "))
            (entry (% (heading (code "GL_HISTOGRAM_ALPHA_SIZE")))
                   (para "
Alpha component counter size, in bits "))
            (entry (% (heading (code "GL_HISTOGRAM_LUMINANCE_SIZE")))
                   (para "
Luminance component counter size, in bits "))
            (entry (% (heading (code "GL_HISTOGRAM_SINK")))
                   (para "
Value of the "
                         (var "sink")
                         " parameter ")))
     (para)
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "target")
           " is not one of the allowable
            values. ")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "pname")
           " is not one of the allowable
            values. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glGetHistogramParameter")
           " is executed
            between the execution of "
           (code "glBegin")
           " and the corresponding
            execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glGetHistogram
  "glGetHistogram"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glGetHistogram"))
      (paramdef "GLenum " (parameter "target"))
      (paramdef "GLboolean " (parameter "reset"))
      (paramdef "GLenum " (parameter "format"))
      (paramdef "GLenum " (parameter "type"))
      (paramdef "GLvoid * " (parameter "values"))))
  '(*fragment*
     (heading "get histogram table")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "target")))
                   (para "
Must be " (code "GL_HISTOGRAM") ". "))
            (entry (% (heading (var "reset")))
                   (para "
If "
                         (code "GL_TRUE")
                         ", each component counter that is actually returned
                    is reset to zero.  (Other counters are unaffected.)
                    If "
                         (code "GL_FALSE")
                         ", none of the counters in the histogram table is modified. "))
            (entry (% (heading (var "format")))
                   (para "
The format of values to be returned in "
                         (var "values")
                         ".
                    Must be one of "
                         (code "GL_RED")
                         ", "
                         (code "GL_GREEN")
                         ", "
                         (code "GL_BLUE")
                         ", "
                         (code "GL_ALPHA")
                         ", "
                         (code "GL_RGB")
                         ", "
                         (code "GL_BGR")
                         ", "
                         (code "GL_RGBA")
                         ", "
                         (code "GL_BGRA")
                         ", "
                         (code "GL_LUMINANCE")
                         ", or "
                         (code "GL_LUMINANCE_ALPHA")
                         ". "))
            (entry (% (heading (var "type")))
                   (para "
The type of values to be returned in "
                         (var "values")
                         ".
                    Symbolic constants "
                         (code "GL_UNSIGNED_BYTE")
                         ", "
                         (code "GL_BYTE")
                         ", "
                         (code "GL_BITMAP")
                         ", "
                         (code "GL_UNSIGNED_SHORT")
                         ", "
                         (code "GL_SHORT")
                         ", "
                         (code "GL_UNSIGNED_INT")
                         ", "
                         (code "GL_INT")
                         ", "
                         (code "GL_FLOAT")
                         ", "
                         (code "GL_UNSIGNED_BYTE_3_3_2")
                         ", "
                         (code "GL_UNSIGNED_BYTE_2_3_3_REV")
                         ", "
                         (code "GL_UNSIGNED_SHORT_5_6_5")
                         ", "
                         (code "GL_UNSIGNED_SHORT_5_6_5_REV")
                         ", "
                         (code "GL_UNSIGNED_SHORT_4_4_4_4")
                         ", "
                         (code "GL_UNSIGNED_SHORT_4_4_4_4_REV")
                         ", "
                         (code "GL_UNSIGNED_SHORT_5_5_5_1")
                         ", "
                         (code "GL_UNSIGNED_SHORT_1_5_5_5_REV")
                         ", "
                         (code "GL_UNSIGNED_INT_8_8_8_8")
                         ", "
                         (code "GL_UNSIGNED_INT_8_8_8_8_REV")
                         ", "
                         (code "GL_UNSIGNED_INT_10_10_10_2")
                         ", and "
                         (code "GL_UNSIGNED_INT_2_10_10_10_REV")
                         "
are accepted. "))
            (entry (% (heading (var "values")))
                   (para "
A pointer to storage for the returned histogram table. ")))
     (heading "Description")
     (para (code "glGetHistogram")
           " returns the current histogram table as a one-dimensional image
            with the same width as the histogram.
            No pixel transfer operations are performed on this image, but pixel storage
            modes that are applicable to 1D images are honored. ")
     (para "
If a non-zero named buffer object is bound to the "
           (code "GL_PIXEL_PACK_BUFFER")
           " target 
            (see "
           (code "glBindBuffer")
           ") while a histogram table is
            requested, "
           (var "values")
           " is treated as a byte offset into the buffer object's data store. ")
     (para "
Color components that are requested in the specified "
           (var "format")
           ", but which
            are not included in the internal format of the histogram, are returned as
            zero.
            The assignments of internal color components to the components
            requested by "
           (var "format")
           " are: ")
     (table (% (formatter (asis)))
            (entry (% (heading (strong "Internal Component")))
                   (para (strong "Resulting Component")))
            (entry (% (heading "
Red ")) (para "
Red "))
            (entry (% (heading "
Green ")) (para "
Green "))
            (entry (% (heading "
Blue ")) (para "
Blue "))
            (entry (% (heading "
Alpha ")) (para "
Alpha "))
            (entry (% (heading "
Luminance "))
                   (para "
Red ")))
     (para)
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "target")
           " is not "
           (code "GL_HISTOGRAM")
           ". ")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "format")
           " is not one of the allowable
            values. ")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "type")
           " is not one of the allowable
            values. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (var "type")
           " is one of "
           (code "GL_UNSIGNED_BYTE_3_3_2")
           ", "
           (code "GL_UNSIGNED_BYTE_2_3_3_REV")
           ", "
           (code "GL_UNSIGNED_SHORT_5_6_5")
           ", or "
           (code "GL_UNSIGNED_SHORT_5_6_5_REV")
           "
and "
           (var "format")
           " is not "
           (code "GL_RGB")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (var "type")
           " is one of "
           (code "GL_UNSIGNED_SHORT_4_4_4_4")
           ", "
           (code "GL_UNSIGNED_SHORT_4_4_4_4_REV")
           ", "
           (code "GL_UNSIGNED_SHORT_5_5_5_1")
           ", "
           (code "GL_UNSIGNED_SHORT_1_5_5_5_REV")
           ", "
           (code "GL_UNSIGNED_INT_8_8_8_8")
           ", "
           (code "GL_UNSIGNED_INT_8_8_8_8_REV")
           ", "
           (code "GL_UNSIGNED_INT_10_10_10_2")
           ", or "
           (code "GL_UNSIGNED_INT_2_10_10_10_REV")
           "
and "
           (var "format")
           " is neither "
           (code "GL_RGBA")
           " nor "
           (code "GL_BGRA")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_PACK_BUFFER")
           " target and the buffer object's data store is currently mapped. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_PACK_BUFFER")
           " target and the data would be packed to the buffer 
            object such that the memory writes required would exceed the data store size. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_PACK_BUFFER")
           " target and "
           (var "values")
           " is not evenly divisible 
            into the number of bytes needed to store in memory a datum indicated by "
           (var "type")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glGetHistogram")
           " is executed
            between the execution of "
           (code "glBegin")
           " and the corresponding
            execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glGetLight
  "glGetLight"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glGetLightfv"))
      (paramdef "GLenum " (parameter "light"))
      (paramdef "GLenum " (parameter "pname"))
      (paramdef "GLfloat * " (parameter "params"))))
  '(*fragment*
     (heading "return light source parameter values")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "light")))
                   (para "
Specifies a light source.
                    The number of possible lights depends on the implementation,
                    but at least eight lights are supported.
                    They are identified by symbolic names of the form "
                         (code "GL_LIGHT")
                         (math (var "i"))
                         "
where "
                         (math (var "i"))
                         "
ranges from 0 to the value of "
                         (code "GL_MAX_LIGHTS")
                         " - 1. "))
            (entry (% (heading (var "pname")))
                   (para "
Specifies a light source parameter for "
                         (var "light")
                         ".
                    Accepted symbolic names are "
                         (code "GL_AMBIENT")
                         ", "
                         (code "GL_DIFFUSE")
                         ", "
                         (code "GL_SPECULAR")
                         ", "
                         (code "GL_POSITION")
                         ", "
                         (code "GL_SPOT_DIRECTION")
                         ", "
                         (code "GL_SPOT_EXPONENT")
                         ", "
                         (code "GL_SPOT_CUTOFF")
                         ", "
                         (code "GL_CONSTANT_ATTENUATION")
                         ", "
                         (code "GL_LINEAR_ATTENUATION")
                         ", and "
                         (code "GL_QUADRATIC_ATTENUATION")
                         ". "))
            (entry (% (heading (var "params")))
                   (para "
Returns the requested data. ")))
     (heading "Description")
     (para (code "glGetLight")
           " returns in "
           (var "params")
           " the value or values of a light source parameter. "
           (var "light")
           " names the light and is a symbolic name of the form "
           (code "GL_LIGHT")
           (math (var "i"))
           "
where i ranges from 0 to the value of "
           (code "GL_MAX_LIGHTS")
           " - 1. "
           (code "GL_MAX_LIGHTS")
           " is an implementation dependent constant that is
            greater than or equal to eight. "
           (var "pname")
           " specifies one of ten light source parameters,
            again by symbolic name. ")
     (para "
The following parameters are defined: ")
     (table (% (formatter (asis)))
            (entry (% (heading (code "GL_AMBIENT")))
                   (para (var "params")
                         " returns four integer or floating-point values representing the
                        ambient intensity of the light source.
                        Integer values,
                        when requested,
                        are linearly mapped from the internal floating-point representation
                        such that 1.0 maps to the most positive representable integer value,
                        and "
                         (math "-1.0")
                         "
maps to the most negative representable integer value.
                        If the internal value is outside the range "
                         (math "[" "-1" "," "1" "]")
                         ",
                        the corresponding integer return value is undefined. The initial value is
                        (0, 0, 0, 1). "))
            (entry (% (heading (code "GL_DIFFUSE")))
                   (para (var "params")
                         " returns four integer or floating-point values representing the
                        diffuse intensity of the light source.
                        Integer values,
                        when requested,
                        are linearly mapped from the internal floating-point representation
                        such that 1.0 maps to the most positive representable integer value,
                        and "
                         (math "-1.0")
                         "
maps to the most negative representable integer value.
                        If the internal value is outside the range "
                         (math "[" "-1" "," "1" "]")
                         ",
                        the corresponding integer return value is undefined. The initial value
                        for "
                         (code "GL_LIGHT0")
                         " is (1, 1, 1, 1); for other lights, the
                        initial value is (0, 0, 0, 0). "))
            (entry (% (heading (code "GL_SPECULAR")))
                   (para (var "params")
                         " returns four integer or floating-point values representing the
                        specular intensity of the light source.
                        Integer values,
                        when requested,
                        are linearly mapped from the internal floating-point representation
                        such that 1.0 maps to the most positive representable integer value,
                        and "
                         (math "-1.0")
                         "
maps to the most negative representable integer value.
                        If the internal value is outside the range "
                         (math "[" "-1" "," "1" "]")
                         ",
                        the corresponding integer return value is undefined. The initial value
                        for "
                         (code "GL_LIGHT0")
                         " is (1, 1, 1, 1); for other lights, the
                        initial value is (0, 0, 0, 0). "))
            (entry (% (heading (code "GL_POSITION")))
                   (para (var "params")
                         " returns four integer or floating-point values representing the
                        position of the light source.
                        Integer values,
                        when requested,
                        are computed by rounding the internal floating-point values to the
                        nearest integer value.
                        The returned values are those maintained in eye coordinates.
                        They will not be equal to the values specified using "
                         (code "glLight")
                         ",
                        unless the modelview matrix was identity at the time "
                         (code "glLight")
                         " was
                        called. The initial value is (0, 0, 1, 0). "))
            (entry (% (heading (code "GL_SPOT_DIRECTION")))
                   (para (var "params")
                         " returns three integer or floating-point values representing the
                        direction of the light source.
                        Integer values,
                        when requested,
                        are computed by rounding the internal floating-point values to the
                        nearest integer value.
                        The returned values are those maintained in eye coordinates.
                        They will not be equal to the values specified using "
                         (code "glLight")
                         ",
                        unless the modelview matrix was identity at the time "
                         (code "glLight")
                         " was called.
                        Although spot direction is normalized before being used in the lighting
                        equation,
                        the returned values are the transformed versions of the specified values
                        prior to normalization. The initial value is "
                         (math "(" "0" "," "0" "-1" ")")
                         ". "))
            (entry (% (heading (code "GL_SPOT_EXPONENT")))
                   (para (var "params")
                         " returns a single integer or floating-point value representing the
                        spot exponent of the light.
                        An integer value,
                        when requested,
                        is computed by rounding the internal floating-point representation to
                        the nearest integer. The initial value is 0. "))
            (entry (% (heading (code "GL_SPOT_CUTOFF")))
                   (para (var "params")
                         " returns a single integer or floating-point value representing the
                        spot cutoff angle of the light.
                        An integer value,
                        when requested,
                        is computed by rounding the internal floating-point representation to
                        the nearest integer. The initial value is 180. "))
            (entry (% (heading (code "GL_CONSTANT_ATTENUATION")))
                   (para (var "params")
                         " returns a single integer or floating-point value representing the
                        constant (not distance-related) attenuation of the light.
                        An integer value,
                        when requested,
                        is computed by rounding the internal floating-point representation to
                        the nearest integer. The initial value is 1. "))
            (entry (% (heading (code "GL_LINEAR_ATTENUATION")))
                   (para (var "params")
                         " returns a single integer or floating-point value representing the
                        linear attenuation of the light.
                        An integer value,
                        when requested,
                        is computed by rounding the internal floating-point representation to
                        the nearest integer. The initial value is 0. "))
            (entry (% (heading (code "GL_QUADRATIC_ATTENUATION")))
                   (para (var "params")
                         " returns a single integer or floating-point value representing the
                        quadratic attenuation of the light.
                        An integer value,
                        when requested,
                        is computed by rounding the internal floating-point representation to
                        the nearest integer. The initial value is 0. ")))
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "light")
           " or "
           (var "pname")
           " is not an
            accepted value. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glGetLight")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glGetMap
  "glGetMap"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glGetMapdv"))
      (paramdef "GLenum " (parameter "target"))
      (paramdef "GLenum " (parameter "query"))
      (paramdef "GLdouble * " (parameter "v"))))
  '(*fragment*
     (heading "return evaluator parameters")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "target")))
                   (para "
Specifies the symbolic name of a map.
                    Accepted values are "
                         (code "GL_MAP1_COLOR_4")
                         ", "
                         (code "GL_MAP1_INDEX")
                         ", "
                         (code "GL_MAP1_NORMAL")
                         ", "
                         (code "GL_MAP1_TEXTURE_COORD_1")
                         ", "
                         (code "GL_MAP1_TEXTURE_COORD_2")
                         ", "
                         (code "GL_MAP1_TEXTURE_COORD_3")
                         ", "
                         (code "GL_MAP1_TEXTURE_COORD_4")
                         ", "
                         (code "GL_MAP1_VERTEX_3")
                         ", "
                         (code "GL_MAP1_VERTEX_4")
                         ", "
                         (code "GL_MAP2_COLOR_4")
                         ", "
                         (code "GL_MAP2_INDEX")
                         ", "
                         (code "GL_MAP2_NORMAL")
                         ", "
                         (code "GL_MAP2_TEXTURE_COORD_1")
                         ", "
                         (code "GL_MAP2_TEXTURE_COORD_2")
                         ", "
                         (code "GL_MAP2_TEXTURE_COORD_3")
                         ", "
                         (code "GL_MAP2_TEXTURE_COORD_4")
                         ", "
                         (code "GL_MAP2_VERTEX_3")
                         ", and "
                         (code "GL_MAP2_VERTEX_4")
                         ". "))
            (entry (% (heading (var "query")))
                   (para "
Specifies which parameter to return.
                    Symbolic names "
                         (code "GL_COEFF")
                         ", "
                         (code "GL_ORDER")
                         ", and "
                         (code "GL_DOMAIN")
                         " are accepted. "))
            (entry (% (heading (var "v")))
                   (para "
Returns the requested data. ")))
     (heading "Description")
     (para (code "glMap1")
           " and "
           (code "glMap2")
           " define evaluators. "
           (code "glGetMap")
           " returns evaluator parameters. "
           (var "target")
           " chooses a map, "
           (var "query")
           " selects a specific parameter,
            and "
           (var "v")
           " points to storage where the values will be returned. ")
     (para "
The acceptable values for the "
           (var "target")
           " parameter are described
            in the "
           (code "glMap1")
           " and "
           (code "glMap2")
           " reference pages. ")
     (para (var "query")
           " can assume the following values: ")
     (table (% (formatter (asis)))
            (entry (% (heading (code "GL_COEFF")))
                   (para (var "v")
                         " returns the control points for the evaluator function.
                        One-dimensional evaluators return "
                         (math (var "order"))
                         "
control points,
                        and two-dimensional evaluators return "
                         (math (var "uorder") "×" (var "vorder"))
                         "
control points.
                        Each control point consists of one, two, three, or four integer,
                        single-precision floating-point,
                        or double-precision floating-point values,
                        depending on the type of the evaluator.
                        The GL returns two-dimensional control points in row-major order,
                        incrementing the "
                         (math (var "uorder"))
                         "
index quickly
                        and the "
                         (math (var "vorder"))
                         "
index after each row.
                        Integer values,
                        when requested,
                        are computed by rounding the internal floating-point values to the
                        nearest integer values. "))
            (entry (% (heading (code "GL_ORDER")))
                   (para (var "v")
                         " returns the order of the evaluator function.
                        One-dimensional evaluators return a single value, "
                         (math (var "order"))
                         ".
                        The initial value is 1.
                        Two-dimensional evaluators return two values, "
                         (math (var "uorder"))
                         "
and "
                         (math (var "vorder"))
                         ".
                        The initial value is 1,1. "))
            (entry (% (heading (code "GL_DOMAIN")))
                   (para (var "v")
                         " returns the linear "
                         (math (var "u"))
                         "
and "
                         (math (var "v"))
                         "
mapping parameters.
                        One-dimensional evaluators return two values, "
                         (math (var "u1"))
                         "
and "
                         (math (var "u2"))
                         ",
                        as specified by "
                         (code "glMap1")
                         ".
                        Two-dimensional evaluators return four values
                        ("
                         (math (var "u1"))
                         ", "
                         (math (var "u2"))
                         ", "
                         (math (var "v1"))
                         ",
                        and "
                         (math (var "v2"))
                         ")
                        as specified by "
                         (code "glMap2")
                         ".
                        Integer values,
                        when requested,
                        are computed by rounding the internal floating-point values to the
                        nearest integer values. ")))
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if either "
           (var "target")
           " or "
           (var "query")
           " is not
            an accepted value. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glGetMap")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glGetMaterial
  "glGetMaterial"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glGetMaterialfv"))
      (paramdef "GLenum " (parameter "face"))
      (paramdef "GLenum " (parameter "pname"))
      (paramdef "GLfloat * " (parameter "params"))))
  '(*fragment*
     (heading "return material parameters")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "face")))
                   (para "
Specifies which of the two materials is being queried. "
                         (code "GL_FRONT")
                         " or "
                         (code "GL_BACK")
                         " are accepted,
                    representing the front and back materials,
                    respectively. "))
            (entry (% (heading (var "pname")))
                   (para "
Specifies the material parameter to return. "
                         (code "GL_AMBIENT")
                         ", "
                         (code "GL_DIFFUSE")
                         ", "
                         (code "GL_SPECULAR")
                         ", "
                         (code "GL_EMISSION")
                         ", "
                         (code "GL_SHININESS")
                         ", and "
                         (code "GL_COLOR_INDEXES")
                         "
are accepted. "))
            (entry (% (heading (var "params")))
                   (para "
Returns the requested data. ")))
     (heading "Description")
     (para (code "glGetMaterial")
           " returns in "
           (var "params")
           " the value or values of parameter "
           (var "pname")
           "
of material "
           (var "face")
           ". Six parameters are defined: ")
     (table (% (formatter (asis)))
            (entry (% (heading (code "GL_AMBIENT")))
                   (para (var "params")
                         " returns four integer or floating-point values representing the
                        ambient reflectance of the material.
                        Integer values,
                        when requested,
                        are linearly mapped from the internal floating-point representation
                        such that 1.0 maps to the most positive representable integer value,
                        and "
                         (math "-1.0")
                         "
maps to the most negative representable integer value.
                        If the internal value is outside the range "
                         (math "[" "-1" "," "1" "]")
                         ",
                        the corresponding integer return value is undefined. The initial value is
                        (0.2, 0.2, 0.2, 1.0) "))
            (entry (% (heading (code "GL_DIFFUSE")))
                   (para (var "params")
                         " returns four integer or floating-point values representing the
                        diffuse reflectance of the material.
                        Integer values,
                        when requested,
                        are linearly mapped from the internal floating-point representation
                        such that 1.0 maps to the most positive representable integer value,
                        and "
                         (math "-1.0")
                         "
maps to the most negative representable integer value.
                        If the internal value is outside the range "
                         (math "[" "-1" "," "1" "]")
                         ",
                        the corresponding integer return value is undefined. The initial value is
                        (0.8, 0.8, 0.8, 1.0). "))
            (entry (% (heading (code "GL_SPECULAR")))
                   (para (var "params")
                         " returns four integer or floating-point values representing the
                        specular reflectance of the material.
                        Integer values,
                        when requested,
                        are linearly mapped from the internal floating-point representation
                        such that 1.0 maps to the most positive representable integer value,
                        and "
                         (math "-1.0")
                         "
maps to the most negative representable integer value.
                        If the internal value is outside the range "
                         (math "[" "-1" "," "1" "]")
                         ",
                        the corresponding integer return value is undefined. The initial value is
                        (0, 0, 0, 1). "))
            (entry (% (heading (code "GL_EMISSION")))
                   (para (var "params")
                         " returns four integer or floating-point values representing the
                        emitted light intensity of the material.
                        Integer values,
                        when requested,
                        are linearly mapped from the internal floating-point representation
                        such that 1.0 maps to the most positive representable integer value,
                        and "
                         (math "-1.0")
                         "
maps to the most negative representable integer value.
                        If the internal value is outside the range "
                         (math "[" "-1" "," "1" "]")
                         ",
                        the corresponding integer return value is undefined. The initial value is
                        (0, 0, 0, 1). "))
            (entry (% (heading (code "GL_SHININESS")))
                   (para (var "params")
                         " returns one integer or floating-point value representing the
                        specular exponent of the material.
                        Integer values,
                        when requested,
                        are computed by rounding the internal floating-point value to the
                        nearest integer value. The initial value is 0. "))
            (entry (% (heading (code "GL_COLOR_INDEXES")))
                   (para (var "params")
                         " returns three integer or floating-point values representing the
                        ambient, diffuse, and specular indices of the material.
                        These indices are used only for color index lighting.
                        (All the other parameters are used only for RGBA lighting.)
                        Integer values,
                        when requested,
                        are computed by rounding the internal floating-point values to the
                        nearest integer values. ")))
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "face")
           " or "
           (var "pname")
           " is not an
            accepted value. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glGetMaterial")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glGetMinmaxParameter
  "glGetMinmaxParameter"
  (funcsynopsis
    (funcprototype
      (funcdef
        "void "
        (function "glGetMinmaxParameterfv"))
      (paramdef "GLenum " (parameter "target"))
      (paramdef "GLenum " (parameter "pname"))
      (paramdef "GLfloat * " (parameter "params"))))
  '(*fragment*
     (heading "get minmax parameters")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "target")))
                   (para "
Must be " (code "GL_MINMAX") ". "))
            (entry (% (heading (var "pname")))
                   (para "
The parameter to be retrieved.
                    Must be one of "
                         (code "GL_MINMAX_FORMAT")
                         " or "
                         (code "GL_MINMAX_SINK")
                         ". "))
            (entry (% (heading (var "params")))
                   (para "
A pointer to storage for the retrieved parameters. ")))
     (heading "Description")
     (para (code "glGetMinmaxParameter")
           " retrieves parameters for the current minmax table by setting "
           (var "pname")
           " to one of the following values: ")
     (para)
     (table (% (formatter (asis)))
            (entry (% (heading (strong "Parameter")))
                   (para (strong "Description")))
            (entry (% (heading (code "GL_MINMAX_FORMAT")))
                   (para "
Internal format of minmax table "))
            (entry (% (heading (code "GL_MINMAX_SINK")))
                   (para "
Value of the "
                         (var "sink")
                         " parameter ")))
     (para)
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "target")
           " is not "
           (code "GL_MINMAX")
           ". ")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "pname")
           " is not one of the allowable
            values. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glGetMinmaxParameter")
           " is executed
            between the execution of "
           (code "glBegin")
           " and the corresponding
            execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glGetMinmax
  "glGetMinmax"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glGetMinmax"))
      (paramdef "GLenum " (parameter "target"))
      (paramdef "GLboolean " (parameter "reset"))
      (paramdef "GLenum " (parameter "format"))
      (paramdef "GLenum " (parameter "types"))
      (paramdef "GLvoid * " (parameter "values"))))
  '(*fragment*
     (heading "get minimum and maximum pixel values")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "target")))
                   (para "
Must be " (code "GL_MINMAX") ". "))
            (entry (% (heading (var "reset")))
                   (para "
If "
                         (code "GL_TRUE")
                         ", all entries in the minmax table that are actually
                    returned are reset to their initial values.  (Other entries are unaltered.)
                    If "
                         (code "GL_FALSE")
                         ", the minmax table is unaltered. "))
            (entry (% (heading (var "format")))
                   (para "
The format of the data to be returned in "
                         (var "values")
                         ".
                    Must be one of "
                         (code "GL_RED")
                         ", "
                         (code "GL_GREEN")
                         ", "
                         (code "GL_BLUE")
                         ", "
                         (code "GL_ALPHA")
                         ", "
                         (code "GL_RGB")
                         ", "
                         (code "GL_BGR")
                         ", "
                         (code "GL_RGBA")
                         ", "
                         (code "GL_BGRA")
                         ", "
                         (code "GL_LUMINANCE")
                         ", or "
                         (code "GL_LUMINANCE_ALPHA")
                         ". "))
            (entry (% (heading (var "types")))
                   (para "
The type of the data to be returned in "
                         (var "values")
                         ".
                    Symbolic constants "
                         (code "GL_UNSIGNED_BYTE")
                         ", "
                         (code "GL_BYTE")
                         ", "
                         (code "GL_BITMAP")
                         ", "
                         (code "GL_UNSIGNED_SHORT")
                         ", "
                         (code "GL_SHORT")
                         ", "
                         (code "GL_UNSIGNED_INT")
                         ", "
                         (code "GL_INT")
                         ", "
                         (code "GL_FLOAT")
                         ", "
                         (code "GL_UNSIGNED_BYTE_3_3_2")
                         ", "
                         (code "GL_UNSIGNED_BYTE_2_3_3_REV")
                         ", "
                         (code "GL_UNSIGNED_SHORT_5_6_5")
                         ", "
                         (code "GL_UNSIGNED_SHORT_5_6_5_REV")
                         ", "
                         (code "GL_UNSIGNED_SHORT_4_4_4_4")
                         ", "
                         (code "GL_UNSIGNED_SHORT_4_4_4_4_REV")
                         ", "
                         (code "GL_UNSIGNED_SHORT_5_5_5_1")
                         ", "
                         (code "GL_UNSIGNED_SHORT_1_5_5_5_REV")
                         ", "
                         (code "GL_UNSIGNED_INT_8_8_8_8")
                         ", "
                         (code "GL_UNSIGNED_INT_8_8_8_8_REV")
                         ", "
                         (code "GL_UNSIGNED_INT_10_10_10_2")
                         ", and "
                         (code "GL_UNSIGNED_INT_2_10_10_10_REV")
                         "
are accepted. "))
            (entry (% (heading (var "values")))
                   (para "
A pointer to storage for the returned values. ")))
     (heading "Description")
     (para (code "glGetMinmax")
           " returns the accumulated minimum and maximum pixel values (computed on a
            per-component basis) in a one-dimensional image of width 2.  The first set
            of return values are the minima, and the second set of return values
            are the maxima.
            The format of the return values is determined by "
           (var "format")
           ", and their type is
            determined by "
           (var "types")
           ". ")
     (para "
If a non-zero named buffer object is bound to the "
           (code "GL_PIXEL_PACK_BUFFER")
           " target 
            (see "
           (code "glBindBuffer")
           ") while minimum and maximum pixel values are
            requested, "
           (var "values")
           " is treated as a byte offset into the buffer object's data store. ")
     (para "
No pixel transfer operations are performed on the return values, but pixel
            storage modes that are applicable to one-dimensional images are performed.
            Color components that are requested in the specified "
           (var "format")
           ", but that
            are not included in the internal format of the minmax table, are
            returned as zero.  The assignment of internal color components to the
            components requested by "
           (var "format")
           " are as follows: ")
     (para)
     (table (% (formatter (asis)))
            (entry (% (heading (strong "Internal Component")))
                   (para (strong "Resulting Component")))
            (entry (% (heading "
Red ")) (para "
Red "))
            (entry (% (heading "
Green ")) (para "
Green "))
            (entry (% (heading "
Blue ")) (para "
Blue "))
            (entry (% (heading "
Alpha ")) (para "
Alpha "))
            (entry (% (heading "
Luminance "))
                   (para "
Red ")))
     (para "
If "
           (var "reset")
           " is "
           (code "GL_TRUE")
           ", the minmax table entries corresponding
            to the return values are reset to their initial
            values.  Minimum and maximum values that are not returned are not
            modified, even if "
           (var "reset")
           " is "
           (code "GL_TRUE")
           ". ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "target")
           " is not "
           (code "GL_MINMAX")
           ". ")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "format")
           " is not one of the allowable
            values. ")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "types")
           " is not one of the allowable
            values. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (var "types")
           " is one of "
           (code "GL_UNSIGNED_BYTE_3_3_2")
           ", "
           (code "GL_UNSIGNED_BYTE_2_3_3_REV")
           ", "
           (code "GL_UNSIGNED_SHORT_5_6_5")
           ", or "
           (code "GL_UNSIGNED_SHORT_5_6_5_REV")
           "
and "
           (var "format")
           " is not "
           (code "GL_RGB")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (var "types")
           " is one of "
           (code "GL_UNSIGNED_SHORT_4_4_4_4")
           ", "
           (code "GL_UNSIGNED_SHORT_4_4_4_4_REV")
           ", "
           (code "GL_UNSIGNED_SHORT_5_5_5_1")
           ", "
           (code "GL_UNSIGNED_SHORT_1_5_5_5_REV")
           ", "
           (code "GL_UNSIGNED_INT_8_8_8_8")
           ", "
           (code "GL_UNSIGNED_INT_8_8_8_8_REV")
           ", "
           (code "GL_UNSIGNED_INT_10_10_10_2")
           ", or "
           (code "GL_UNSIGNED_INT_2_10_10_10_REV")
           "
and "
           (var "format")
           " is neither "
           (code "GL_RGBA")
           " nor "
           (code "GL_BGRA")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_PACK_BUFFER")
           " target and the buffer object's data store is currently mapped. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_PACK_BUFFER")
           " target and the data would be packed to the buffer 
            object such that the memory writes required would exceed the data store size. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_PACK_BUFFER")
           " target and "
           (var "values")
           " is not evenly divisible 
            into the number of bytes needed to store in memory a datum indicated by "
           (var "type")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glGetMinmax")
           " is executed
            between the execution of "
           (code "glBegin")
           " and the corresponding
            execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glGetPixelMap
  "glGetPixelMap"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glGetPixelMapfv"))
      (paramdef "GLenum " (parameter "map"))
      (paramdef "GLfloat * " (parameter "data"))))
  '(*fragment*
     (heading "return the specified pixel map")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "map")))
                   (para "
Specifies the name of the pixel map to return.
                    Accepted values are "
                         (code "GL_PIXEL_MAP_I_TO_I")
                         ", "
                         (code "GL_PIXEL_MAP_S_TO_S")
                         ", "
                         (code "GL_PIXEL_MAP_I_TO_R")
                         ", "
                         (code "GL_PIXEL_MAP_I_TO_G")
                         ", "
                         (code "GL_PIXEL_MAP_I_TO_B")
                         ", "
                         (code "GL_PIXEL_MAP_I_TO_A")
                         ", "
                         (code "GL_PIXEL_MAP_R_TO_R")
                         ", "
                         (code "GL_PIXEL_MAP_G_TO_G")
                         ", "
                         (code "GL_PIXEL_MAP_B_TO_B")
                         ", and "
                         (code "GL_PIXEL_MAP_A_TO_A")
                         ". "))
            (entry (% (heading (var "data")))
                   (para "
Returns the pixel map contents. ")))
     (heading "Description")
     (para "
See the "
           (code "glPixelMap")
           " reference page for a description of the acceptable
            values for the "
           (var "map")
           " parameter. "
           (code "glGetPixelMap")
           " returns in "
           (var "data")
           " the contents of the pixel map
            specified in "
           (var "map")
           ".
            Pixel maps are used during the execution of "
           (code "glReadPixels")
           ", "
           (code "glDrawPixels")
           ", "
           (code "glCopyPixels")
           ", "
           (code "glTexImage1D")
           ", "
           (code "glTexImage2D")
           ", "
           (code "glTexImage3D")
           ", "
           (code "glTexSubImage1D")
           ", "
           (code "glTexSubImage2D")
           ", "
           (code "glTexSubImage3D")
           ", "
           (code "glCopyTexImage1D")
           ", "
           (code "glCopyTexImage2D")
           ", "
           (code "glCopyTexSubImage1D")
           ", "
           (code "glCopyTexSubImage2D")
           ", and "
           (code "glCopyTexSubImage3D")
           ".
            to map color indices,
            stencil indices,
            color components,
            and depth components to other values. ")
     (para "
If a non-zero named buffer object is bound to the "
           (code "GL_PIXEL_PACK_BUFFER")
           " target 
            (see "
           (code "glBindBuffer")
           ") while a pixel map is
            requested, "
           (var "data")
           " is treated as a byte offset into the buffer object's data store. ")
     (para "
Unsigned integer values,
            if requested,
            are linearly mapped from the internal fixed or floating-point representation
            such that 1.0 maps to the largest representable integer value,
            and 0.0 maps to 0.
            Return unsigned integer values are undefined if the map value was
            not in the range [0,1]. ")
     (para "
To determine the required size of "
           (var "map")
           ",
            call "
           (code "glGet")
           " with the appropriate symbolic
            constant. ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "map")
           " is not an accepted value. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_PACK_BUFFER")
           " target and the buffer object's data store is currently mapped. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_PACK_BUFFER")
           " target and the data would be packed to the buffer 
            object such that the memory writes required would exceed the data store size. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated by "
           (code "glGetPixelMapfv")
           " if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_PACK_BUFFER")
           " target and "
           (var "data")
           " is not evenly divisible 
            into the number of bytes needed to store in memory a GLfloat datum. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated by "
           (code "glGetPixelMapuiv")
           " if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_PACK_BUFFER")
           " target and "
           (var "data")
           " is not evenly divisible 
            into the number of bytes needed to store in memory a GLuint datum. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated by "
           (code "glGetPixelMapusv")
           " if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_PACK_BUFFER")
           " target and "
           (var "data")
           " is not evenly divisible 
            into the number of bytes needed to store in memory a GLushort datum. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glGetPixelMap")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glGetPointerv
  "glGetPointerv"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glGetPointerv"))
      (paramdef "GLenum " (parameter "pname"))
      (paramdef "GLvoid ** " (parameter "params"))))
  '(*fragment*
     (heading
       "return the address of the specified pointer")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "pname")))
                   (para "
Specifies the array or buffer pointer to be returned.
                    Symbolic constants "
                         (code "GL_COLOR_ARRAY_POINTER")
                         ", "
                         (code "GL_EDGE_FLAG_ARRAY_POINTER")
                         ", "
                         (code "GL_FOG_COORD_ARRAY_POINTER")
                         ", "
                         (code "GL_FEEDBACK_BUFFER_POINTER")
                         ", "
                         (code "GL_INDEX_ARRAY_POINTER")
                         ", "
                         (code "GL_NORMAL_ARRAY_POINTER")
                         ", "
                         (code "GL_SECONDARY_COLOR_ARRAY_POINTER")
                         ", "
                         (code "GL_SELECTION_BUFFER_POINTER")
                         ", "
                         (code "GL_TEXTURE_COORD_ARRAY_POINTER")
                         ",
                    or "
                         (code "GL_VERTEX_ARRAY_POINTER")
                         "
are accepted. "))
            (entry (% (heading (var "params")))
                   (para "
Returns the pointer value specified by "
                         (var "pname")
                         ". ")))
     (heading "Description")
     (para (code "glGetPointerv")
           " returns pointer information. "
           (var "pname")
           " is a symbolic constant
            indicating the pointer to be returned, and "
           (var "params")
           " is a pointer to a
            location in which to place the returned data. ")
     (para "
For all "
           (var "pname")
           " arguments except "
           (code "GL_FEEDBACK_BUFFER_POINTER")
           " and "
           (code "GL_SELECTION_BUFFER_POINTER")
           ",
            if a non-zero named buffer object was bound to the "
           (code "GL_ARRAY_BUFFER")
           " target 
            (see "
           (code "glBindBuffer")
           ") when the desired pointer was previously
            specified, the pointer returned is a byte offset into the buffer object's data store.
            Buffer objects are only available in OpenGL versions 1.5 and greater. ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "pname")
           " is not an accepted value. ")))

(define-gl-procedure
  glGetPolygonStipple
  "glGetPolygonStipple"
  (funcsynopsis
    (funcprototype
      (funcdef
        "void "
        (function "glGetPolygonStipple"))
      (paramdef "GLubyte * " (parameter "pattern"))))
  '(*fragment*
     (heading "return the polygon stipple pattern")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "pattern")))
                   (para "
Returns the stipple pattern. The initial value is all 1's. ")))
     (heading "Description")
     (para (code "glGetPolygonStipple")
           " returns to "
           (var "pattern")
           " a "
           (math "32" "×" "32")
           "
polygon stipple pattern.
            The pattern is packed into memory as if "
           (code "glReadPixels")
           "
with both "
           (var "height")
           " and "
           (var "width")
           " of 32, "
           (var "type")
           " of "
           (code "GL_BITMAP")
           ",
            and "
           (var "format")
           " of "
           (code "GL_COLOR_INDEX")
           " were called,
            and the stipple pattern were stored in an internal "
           (math "32" "×" "32")
           "
color
            index buffer.
            Unlike "
           (code "glReadPixels")
           ",
            however,
            pixel transfer operations
            (shift, offset, pixel map)
            are not applied to the returned stipple image. ")
     (para "
If a non-zero named buffer object is bound to the "
           (code "GL_PIXEL_PACK_BUFFER")
           " target 
            (see "
           (code "glBindBuffer")
           ") while a polygon stipple pattern is
            requested, "
           (var "pattern")
           " is treated as a byte offset into the buffer object's data store. ")
     (heading "Errors")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_PACK_BUFFER")
           " target and the buffer object's data store is currently mapped. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_PACK_BUFFER")
           " target and the data would be packed to the buffer 
            object such that the memory writes required would exceed the data store size. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glGetPolygonStipple")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glGetProgramInfoLog
  "glGetProgramInfoLog"
  (funcsynopsis
    (funcprototype
      (funcdef
        "void "
        (function "glGetProgramInfoLog"))
      (paramdef "GLuint " (parameter "program"))
      (paramdef "GLsizei " (parameter "maxLength"))
      (paramdef "GLsizei *" (parameter "length"))
      (paramdef "GLchar *" (parameter "infoLog"))))
  '(*fragment*
     (heading
       "Returns the information log for a program object")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "program")))
                   (para "Specifies the program object whose information
\t\t    log is to be queried."))
            (entry (% (heading (var "maxLength")))
                   (para "Specifies the size of the character buffer for
\t\t    storing the returned information log."))
            (entry (% (heading (var "length")))
                   (para "Returns the length of the string returned in "
                         (var "infoLog")
                         " (excluding the null
\t\t    terminator)."))
            (entry (% (heading (var "infoLog")))
                   (para "Specifies an array of characters that is used
\t\t    to return the information log.")))
     (heading "Description")
     (para (code "glGetProgramInfoLog")
           " returns the
\tinformation log for the specified program object. The
\tinformation log for a program object is modified when the
\tprogram object is linked or validated. The string that is
\treturned will be null terminated.")
     (para (code "glGetProgramInfoLog")
           " returns in\t"
           (var "infoLog")
           " as much of the information log as
\tit can, up to a maximum of "
           (var "maxLength")
           "
characters. The number of characters actually returned,
\texcluding the null termination character, is specified by\t"
           (var "length")
           ". If the length of the returned
\tstring is not required, a value of "
           (code "NULL")
           " can
\tbe passed in the "
           (var "length")
           " argument. The
\tsize of the buffer required to store the returned information
\tlog can be obtained by calling\t"
           (code "glGetProgram")
           "
with the value "
           (code "GL_INFO_LOG_LENGTH")
           ". ")
     (para "The information log for a program object is either an
\tempty string, or a string containing information about the last
\tlink operation, or a string containing information about the
\tlast validation operation. It may contain diagnostic messages,
\twarning messages, and other information. When a program object
\tis created, its information log will be a string of length
\t0.")
     (heading "Errors")
     (para (code "GL_INVALID_VALUE")
           " is generated if\t"
           (var "program")
           " is not a value generated by
\tOpenGL.")
     (para (code "GL_INVALID_OPERATION")
           " is generated if\t"
           (var "program")
           " is not a program object.")
     (para (code "GL_INVALID_VALUE")
           " is generated if\t"
           (var "maxLength")
           " is less than 0.")
     (para (code "GL_INVALID_OPERATION")
           " is generated if\t"
           (code "glGetProgramInfoLog")
           " is executed between the
\texecution of\t"
           (code "glBegin")
           "
and the corresponding execution of\t"
           (code "glEnd")
           ".")))

(define-gl-procedure
  glGetProgramiv
  "glGetProgramiv"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glGetProgramiv"))
      (paramdef "GLuint " (parameter "program"))
      (paramdef "GLenum " (parameter "pname"))
      (paramdef "GLint *" (parameter "params"))))
  '(*fragment*
     (heading
       "Returns a parameter from a program object")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "program")))
                   (para "Specifies the program object to be
\t\t    queried."))
            (entry (% (heading (var "pname")))
                   (para "Specifies the object parameter. Accepted
\t\t    symbolic names are "
                         (code "GL_DELETE_STATUS")
                         ", "
                         (code "GL_LINK_STATUS")
                         ", "
                         (code "GL_VALIDATE_STATUS")
                         ", "
                         (code "GL_INFO_LOG_LENGTH")
                         ", "
                         (code "GL_ATTACHED_SHADERS")
                         ", "
                         (code "GL_ACTIVE_ATTRIBUTES")
                         ", "
                         (code "GL_ACTIVE_ATTRIBUTE_MAX_LENGTH")
                         ", "
                         (code "GL_ACTIVE_UNIFORMS")
                         ", "
                         (code "GL_ACTIVE_UNIFORM_MAX_LENGTH")
                         "."))
            (entry (% (heading (var "params")))
                   (para "Returns the requested object parameter.")))
     (heading "Description")
     (para (code "glGetProgram")
           "
returns in "
           (var "params")
           "
the value of a parameter for a specific program object. The following parameters are defined:")
     (table (% (formatter (asis)))
            (entry (% (heading (code "GL_DELETE_STATUS")))
                   (para)
                   (para (var "params")
                         " returns "
                         (code "GL_TRUE")
                         " if "
                         (var "program")
                         " is currently flagged
\t\t    for deletion, and "
                         (code "GL_FALSE")
                         "
otherwise."))
            (entry (% (heading (code "GL_LINK_STATUS")))
                   (para)
                   (para (var "params")
                         " returns "
                         (code "GL_TRUE")
                         " if the last link
\t\t    operation on "
                         (var "program")
                         " was
\t\t    successful, and "
                         (code "GL_FALSE")
                         "
otherwise."))
            (entry (% (heading (code "GL_VALIDATE_STATUS")))
                   (para)
                   (para (var "params")
                         " returns "
                         (code "GL_TRUE")
                         " or if the last
\t\t    validation operation on "
                         (var "program")
                         " was successful, and "
                         (code "GL_FALSE")
                         "
otherwise."))
            (entry (% (heading (code "GL_INFO_LOG_LENGTH")))
                   (para)
                   (para (var "params")
                         " returns the
\t\t    number of characters in the information log for "
                         (var "program")
                         " including the null
\t\t    termination character (i.e., the size of the
\t\t    character buffer required to store the information
\t\t    log). If "
                         (var "program")
                         " has no
\t\t    information log, a value of 0 is
\t\t    returned."))
            (entry (% (heading (code "GL_ATTACHED_SHADERS")))
                   (para)
                   (para (var "params")
                         " returns the
\t\t    number of shader objects attached to "
                         (var "program")
                         "."))
            (entry (% (heading (code "GL_ACTIVE_ATTRIBUTES")))
                   (para)
                   (para (var "params")
                         " returns the
\t\t    number of active attribute variables for "
                         (var "program")
                         "."))
            (entry (% (heading (code "GL_ACTIVE_ATTRIBUTE_MAX_LENGTH")))
                   (para)
                   (para (var "params")
                         " returns the
\t\t    length of the longest active attribute name for "
                         (var "program")
                         ", including the null
\t\t    termination character (i.e., the size of the
\t\t    character buffer required to store the longest
\t\t    attribute name). If no active attributes exist, 0 is
\t\t    returned."))
            (entry (% (heading (code "GL_ACTIVE_UNIFORMS")))
                   (para)
                   (para (var "params")
                         " returns the
\t\t    number of active uniform variables for "
                         (var "program")
                         "."))
            (entry (% (heading (code "GL_ACTIVE_UNIFORM_MAX_LENGTH")))
                   (para)
                   (para (var "params")
                         " returns the
\t\t    length of the longest active uniform variable name
\t\t    for "
                         (var "program")
                         ", including the
\t\t    null termination character (i.e., the size of the
\t\t    character buffer required to store the longest
\t\t    uniform variable name). If no active uniform
\t\t    variables exist, 0 is returned.")))
     (heading "Errors")
     (para (code "GL_INVALID_VALUE")
           "
is generated if "
           (var "program")
           "
is not a value generated by OpenGL.")
     (para (code "GL_INVALID_OPERATION")
           "
is generated if "
           (var "program")
           "
does not refer to a program object.")
     (para (code "GL_INVALID_ENUM")
           "
is generated if "
           (var "pname")
           "
is not an accepted value.")
     (para (code "GL_INVALID_OPERATION")
           " is generated if\t"
           (code "glGetProgram")
           " is executed between the
\texecution of\t"
           (code "glBegin")
           "
and the corresponding execution of\t"
           (code "glEnd")
           ".")))

(define-gl-procedure
  glGetQueryiv
  "glGetQueryiv"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glGetQueryiv"))
      (paramdef "GLenum " (parameter "target"))
      (paramdef "GLenum " (parameter "pname"))
      (paramdef "GLint * " (parameter "params"))))
  '(*fragment*
     (heading
       "return parameters of a query object target")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "target")))
                   (para "
Specifies a query object target.
                    Must be "
                         (code "GL_SAMPLES_PASSED")
                         ". "))
            (entry (% (heading (var "pname")))
                   (para "
Specifies the symbolic name of a query object target parameter.
                    Accepted values are "
                         (code "GL_CURRENT_QUERY")
                         " or "
                         (code "GL_QUERY_COUNTER_BITS")
                         ". "))
            (entry (% (heading (var "params")))
                   (para "
Returns the requested data. ")))
     (heading "Description")
     (para (code "glGetQueryiv")
           " returns in "
           (var "params")
           " a selected parameter of the query object target
            specified by "
           (var "target")
           ". ")
     (para (var "pname")
           " names a specific query object target parameter.  When "
           (var "target")
           " is "
           (code "GL_SAMPLES_PASSED")
           ", "
           (var "pname")
           " can be as follows: ")
     (table (% (formatter (asis)))
            (entry (% (heading (code "GL_CURRENT_QUERY")))
                   (para (var "params")
                         " returns the name of the currently active occlusion query object.
                        If no occlusion query is active, 0 is returned.  The initial value is 0. "))
            (entry (% (heading (code "GL_QUERY_COUNTER_BITS")))
                   (para (var "params")
                         " returns the number of bits in the query counter used to accumulate passing samples.
                        If the number of bits returned is 0, the implementation does not support a query counter, and the results 
                        obtained from "
                         (code "glGetQueryObject")
                         " are useless. ")))
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "target")
           " or "
           (var "pname")
           " is not an
            accepted value. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glGetQueryiv")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glGetQueryObject
  "glGetQueryObject"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glGetQueryObjectiv"))
      (paramdef "GLuint " (parameter "id"))
      (paramdef "GLenum " (parameter "pname"))
      (paramdef "GLint * " (parameter "params"))))
  '(*fragment*
     (heading "return parameters of a query object")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "id")))
                   (para "
Specifies the name of a query object. "))
            (entry (% (heading (var "pname")))
                   (para "
Specifies the symbolic name of a query object parameter.
                    Accepted values are "
                         (code "GL_QUERY_RESULT")
                         " or "
                         (code "GL_QUERY_RESULT_AVAILABLE")
                         ". "))
            (entry (% (heading (var "params")))
                   (para "
Returns the requested data. ")))
     (heading "Description")
     (para (code "glGetQueryObject")
           " returns in "
           (var "params")
           " a selected parameter of the query object
            specified by "
           (var "id")
           ". ")
     (para (var "pname")
           " names a specific query object parameter. "
           (var "pname")
           " can be as follows: ")
     (table (% (formatter (asis)))
            (entry (% (heading (code "GL_QUERY_RESULT")))
                   (para (var "params")
                         " returns the value of the query object's passed samples counter.  
                        The initial value is 0. "))
            (entry (% (heading (code "GL_QUERY_RESULT_AVAILABLE")))
                   (para (var "params")
                         " returns whether the passed samples counter is immediately available.
                        If a delay would occur waiting for the query result, "
                         (code "GL_FALSE")
                         " is returned.  
                        Otherwise, "
                         (code "GL_TRUE")
                         " is returned, which also indicates that the results of all
                        previous queries are available as well. ")))
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "pname")
           " is not an accepted value. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (var "id")
           " is not the name of a query object. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (var "id")
           " is the name of a currently active 
            query object. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glGetQueryObject")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glGetSeparableFilter
  "glGetSeparableFilter"
  (funcsynopsis
    (funcprototype
      (funcdef
        "void "
        (function "glGetSeparableFilter"))
      (paramdef "GLenum " (parameter "target"))
      (paramdef "GLenum " (parameter "format"))
      (paramdef "GLenum " (parameter "type"))
      (paramdef "GLvoid * " (parameter "row"))
      (paramdef "GLvoid * " (parameter "column"))
      (paramdef "GLvoid * " (parameter "span"))))
  '(*fragment*
     (heading
       "get separable convolution filter kernel images")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "target")))
                   (para "
The separable filter to be retrieved.
                    Must be "
                         (code "GL_SEPARABLE_2D")
                         ". "))
            (entry (% (heading (var "format")))
                   (para "
Format of the output images.
                    Must be one of "
                         (code "GL_RED")
                         ", "
                         (code "GL_GREEN")
                         ", "
                         (code "GL_BLUE")
                         ", "
                         (code "GL_ALPHA")
                         ", "
                         (code "GL_RGB")
                         ", "
                         (code "GL_BGR")
                         (code "GL_RGBA")
                         ", "
                         (code "GL_BGRA")
                         ", "
                         (code "GL_LUMINANCE")
                         ", or "
                         (code "GL_LUMINANCE_ALPHA")
                         ". "))
            (entry (% (heading (var "type")))
                   (para "
Data type of components in the output images.
                    Symbolic constants "
                         (code "GL_UNSIGNED_BYTE")
                         ", "
                         (code "GL_BYTE")
                         ", "
                         (code "GL_BITMAP")
                         ", "
                         (code "GL_UNSIGNED_SHORT")
                         ", "
                         (code "GL_SHORT")
                         ", "
                         (code "GL_UNSIGNED_INT")
                         ", "
                         (code "GL_INT")
                         ", "
                         (code "GL_FLOAT")
                         ", "
                         (code "GL_UNSIGNED_BYTE_3_3_2")
                         ", "
                         (code "GL_UNSIGNED_BYTE_2_3_3_REV")
                         ", "
                         (code "GL_UNSIGNED_SHORT_5_6_5")
                         ", "
                         (code "GL_UNSIGNED_SHORT_5_6_5_REV")
                         ", "
                         (code "GL_UNSIGNED_SHORT_4_4_4_4")
                         ", "
                         (code "GL_UNSIGNED_SHORT_4_4_4_4_REV")
                         ", "
                         (code "GL_UNSIGNED_SHORT_5_5_5_1")
                         ", "
                         (code "GL_UNSIGNED_SHORT_1_5_5_5_REV")
                         ", "
                         (code "GL_UNSIGNED_INT_8_8_8_8")
                         ", "
                         (code "GL_UNSIGNED_INT_8_8_8_8_REV")
                         ", "
                         (code "GL_UNSIGNED_INT_10_10_10_2")
                         ", and "
                         (code "GL_UNSIGNED_INT_2_10_10_10_REV")
                         "
are accepted. "))
            (entry (% (heading (var "row")))
                   (para "
Pointer to storage for the row filter image. "))
            (entry (% (heading (var "column")))
                   (para "
Pointer to storage for the column filter image. "))
            (entry (% (heading (var "span")))
                   (para "
Pointer to storage for the span filter image (currently unused). ")))
     (heading "Description")
     (para (code "glGetSeparableFilter")
           " returns the two one-dimensional filter kernel images for the
            current separable 2D convolution filter.
            The row image is placed in "
           (var "row")
           " and the column image is placed in "
           (var "column")
           " according to the specifications in "
           (var "format")
           " and "
           (var "type")
           ".
            (In the current implementation, "
           (var "span")
           " is not affected in any way.)
            No pixel transfer operations are performed on the images, but the relevant
            pixel storage modes are applied. ")
     (para "
If a non-zero named buffer object is bound to the "
           (code "GL_PIXEL_PACK_BUFFER")
           " target 
            (see "
           (code "glBindBuffer")
           ") while a separable convolution filter is
            requested, "
           (var "row")
           ", "
           (var "column")
           ", and "
           (var "span")
           " are treated as a byte offset into the buffer object's data store. ")
     (para "
Color components that are present in "
           (var "format")
           " but not included in the
            internal format of the filters are returned as zero.
            The assignments of internal color components to the components of "
           (var "format")
           "
are as follows: ")
     (para)
     (table (% (formatter (asis)))
            (entry (% (heading (strong "Internal Component")))
                   (para (strong "Resulting Component")))
            (entry (% (heading "
Red ")) (para "
Red "))
            (entry (% (heading "
Green ")) (para "
Green "))
            (entry (% (heading "
Blue ")) (para "
Blue "))
            (entry (% (heading "
Alpha ")) (para "
Alpha "))
            (entry (% (heading "
Luminance "))
                   (para "
Red "))
            (entry (% (heading "
Intensity "))
                   (para "
Red ")))
     (para)
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "target")
           " is not "
           (code "GL_SEPARABLE_2D")
           ". ")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "format")
           " is not one of the allowable
            values. ")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "type")
           " is not one of the allowable
            values. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (var "type")
           " is one of "
           (code "GL_UNSIGNED_BYTE_3_3_2")
           ", "
           (code "GL_UNSIGNED_BYTE_2_3_3_REV")
           ", "
           (code "GL_UNSIGNED_SHORT_5_6_5")
           ", or "
           (code "GL_UNSIGNED_SHORT_5_6_5_REV")
           "
and "
           (var "format")
           " is not "
           (code "GL_RGB")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (var "type")
           " is one of "
           (code "GL_UNSIGNED_SHORT_4_4_4_4")
           ", "
           (code "GL_UNSIGNED_SHORT_4_4_4_4_REV")
           ", "
           (code "GL_UNSIGNED_SHORT_5_5_5_1")
           ", "
           (code "GL_UNSIGNED_SHORT_1_5_5_5_REV")
           ", "
           (code "GL_UNSIGNED_INT_8_8_8_8")
           ", "
           (code "GL_UNSIGNED_INT_8_8_8_8_REV")
           ", "
           (code "GL_UNSIGNED_INT_10_10_10_2")
           ", or "
           (code "GL_UNSIGNED_INT_2_10_10_10_REV")
           "
and "
           (var "format")
           " is neither "
           (code "GL_RGBA")
           " nor "
           (code "GL_BGRA")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_PACK_BUFFER")
           " target and the buffer object's data store is currently mapped. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_PACK_BUFFER")
           " target and the data would be packed to the buffer 
            object such that the memory writes required would exceed the data store size. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_PACK_BUFFER")
           " target and "
           (var "row")
           " or "
           (var "column")
           " is not evenly divisible 
            into the number of bytes needed to store in memory a datum indicated by "
           (var "type")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glGetSeparableFilter")
           " is executed
            between the execution of "
           (code "glBegin")
           " and the corresponding
            execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glGetShaderInfoLog
  "glGetShaderInfoLog"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glGetShaderInfoLog"))
      (paramdef "GLuint " (parameter "shader"))
      (paramdef "GLsizei " (parameter "maxLength"))
      (paramdef "GLsizei *" (parameter "length"))
      (paramdef "GLchar *" (parameter "infoLog"))))
  '(*fragment*
     (heading
       "Returns the information log for a shader object")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "shader")))
                   (para "Specifies the shader object whose information
\t\t    log is to be queried."))
            (entry (% (heading (var "maxLength")))
                   (para "Specifies the size of the character buffer for
\t\t    storing the returned information log."))
            (entry (% (heading (var "length")))
                   (para "Returns the length of the string returned in "
                         (var "infoLog")
                         " (excluding the null
\t\t    terminator)."))
            (entry (% (heading (var "infoLog")))
                   (para "Specifies an array of characters that is used
\t\t    to return the information log.")))
     (heading "Description")
     (para (code "glGetShaderInfoLog")
           " returns the
\tinformation log for the specified shader object. The information
\tlog for a shader object is modified when the shader is compiled.
\tThe string that is returned will be null terminated.")
     (para (code "glGetShaderInfoLog")
           " returns in\t"
           (var "infoLog")
           " as much of the information log as
\tit can, up to a maximum of "
           (var "maxLength")
           "
characters. The number of characters actually returned,
\texcluding the null termination character, is specified by\t"
           (var "length")
           ". If the length of the returned
\tstring is not required, a value of "
           (code "NULL")
           " can
\tbe passed in the "
           (var "length")
           " argument. The
\tsize of the buffer required to store the returned information
\tlog can be obtained by calling\t"
           (code "glGetShader")
           "
with the value "
           (code "GL_INFO_LOG_LENGTH")
           ".")
     (para "The information log for a shader object is a string that
\tmay contain diagnostic messages, warning messages, and other
\tinformation about the last compile operation. When a shader
\tobject is created, its information log will be a string of
\tlength 0.")
     (heading "Errors")
     (para (code "GL_INVALID_VALUE")
           " is generated if\t"
           (var "shader")
           " is not a value generated by
\tOpenGL.")
     (para (code "GL_INVALID_OPERATION")
           " is generated if\t"
           (var "shader")
           " is not a shader object.")
     (para (code "GL_INVALID_VALUE")
           " is generated if\t"
           (var "maxLength")
           " is less than 0.")
     (para (code "GL_INVALID_OPERATION")
           " is generated if\t"
           (code "glGetShaderInfoLog")
           " is executed between the
\texecution of\t"
           (code "glBegin")
           "
and the corresponding execution of\t"
           (code "glEnd")
           ".")))

(define-gl-procedure
  glGetShaderSource
  "glGetShaderSource"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glGetShaderSource"))
      (paramdef "GLuint " (parameter "shader"))
      (paramdef "GLsizei " (parameter "bufSize"))
      (paramdef "GLsizei *" (parameter "length"))
      (paramdef "GLchar *" (parameter "source"))))
  '(*fragment*
     (heading
       "Returns the source code string from a shader object")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "shader")))
                   (para "Specifies the shader object to be
\t\t    queried."))
            (entry (% (heading (var "bufSize")))
                   (para "Specifies the size of the character buffer for
\t\t    storing the returned source code string."))
            (entry (% (heading (var "length")))
                   (para "Returns the length of the string returned in "
                         (var "source")
                         " (excluding the null
\t\t    terminator)."))
            (entry (% (heading (var "source")))
                   (para "Specifies an array of characters that is used
\t\t    to return the source code string.")))
     (heading "Description")
     (para (code "glGetShaderSource")
           " returns the
\tconcatenation of the source code strings from the shader object
\tspecified by "
           (var "shader")
           ". The source code
\tstrings for a shader object are the result of a previous call to\t"
           (code "glShaderSource")
           ".
\tThe string returned by the function will be null
\tterminated.")
     (para (code "glGetShaderSource")
           " returns in\t"
           (var "source")
           " as much of the source code string
\tas it can, up to a maximum of "
           (var "bufSize")
           "
characters. The number of characters actually returned,
\texcluding the null termination character, is specified by\t"
           (var "length")
           ". If the length of the returned
\tstring is not required, a value of "
           (code "NULL")
           " can
\tbe passed in the "
           (var "length")
           " argument. The
\tsize of the buffer required to store the returned source code
\tstring can be obtained by calling\t"
           (code "glGetShader")
           "
with the value\t"
           (code "GL_SHADER_SOURCE_LENGTH")
           ".")
     (heading "Errors")
     (para (code "GL_INVALID_VALUE")
           " is generated if\t"
           (var "shader")
           " is not a value generated by
\tOpenGL.")
     (para (code "GL_INVALID_OPERATION")
           " is generated if\t"
           (var "shader")
           " is not a shader object.")
     (para (code "GL_INVALID_VALUE")
           " is generated if\t"
           (var "bufSize")
           " is less than 0.")
     (para (code "GL_INVALID_OPERATION")
           " is generated if\t"
           (code "glGetShaderSource")
           " is executed between the
\texecution of\t"
           (code "glBegin")
           "
and the corresponding execution of\t"
           (code "glEnd")
           ".")))

(define-gl-procedure
  glGetShaderiv
  "glGetShaderiv"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glGetShaderiv"))
      (paramdef "GLuint " (parameter "shader"))
      (paramdef "GLenum " (parameter "pname"))
      (paramdef "GLint *" (parameter "params"))))
  '(*fragment*
     (heading
       "Returns a parameter from a shader object")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "shader")))
                   (para "Specifies the shader object to be
\t\t    queried."))
            (entry (% (heading (var "pname")))
                   (para "Specifies the object parameter. Accepted
\t\t    symbolic names are "
                         (code "GL_SHADER_TYPE")
                         ", "
                         (code "GL_DELETE_STATUS")
                         ", "
                         (code "GL_COMPILE_STATUS")
                         ", "
                         (code "GL_INFO_LOG_LENGTH")
                         ", "
                         (code "GL_SHADER_SOURCE_LENGTH")
                         "."))
            (entry (% (heading (var "params")))
                   (para "Returns the requested object parameter.")))
     (heading "Description")
     (para (code "glGetShader")
           "
returns in "
           (var "params")
           "
the value of a parameter for a specific shader object. The
\tfollowing parameters are defined:")
     (table (% (formatter (asis)))
            (entry (% (heading (code "GL_SHADER_TYPE")))
                   (para (var "params")
                         " returns "
                         (code "GL_VERTEX_SHADER")
                         " if "
                         (var "shader")
                         " is a vertex shader
\t\t    object, and "
                         (code "GL_FRAGMENT_SHADER")
                         "
if "
                         (var "shader")
                         " is a fragment
\t\t    shader object."))
            (entry (% (heading (code "GL_DELETE_STATUS")))
                   (para (var "params")
                         " returns "
                         (code "GL_TRUE")
                         " if "
                         (var "shader")
                         " is currently flagged
\t\t    for deletion, and "
                         (code "GL_FALSE")
                         "
otherwise."))
            (entry (% (heading (code "GL_COMPILE_STATUS")))
                   (para (var "params")
                         " returns "
                         (code "GL_TRUE")
                         " if the last compile
\t\t    operation on "
                         (var "shader")
                         " was
\t\t    successful, and "
                         (code "GL_FALSE")
                         "
otherwise."))
            (entry (% (heading (code "GL_INFO_LOG_LENGTH")))
                   (para (var "params")
                         " returns the
\t\t    number of characters in the information log for "
                         (var "shader")
                         " including the null
\t\t    termination character (i.e., the size of the
\t\t    character buffer required to store the information
\t\t    log). If "
                         (var "shader")
                         " has no
\t\t    information log, a value of 0 is returned."))
            (entry (% (heading (code "GL_SHADER_SOURCE_LENGTH")))
                   (para (var "params")
                         " returns the
\t\t    length of the concatenation of the source strings
\t\t    that make up the shader source for the "
                         (var "shader")
                         ", including the null
\t\t    termination character. (i.e., the size of the
\t\t    character buffer required to store the shader
\t\t    source). If no source code exists, 0 is
\t\t    returned.")))
     (heading "Errors")
     (para (code "GL_INVALID_VALUE")
           " is generated if\t"
           (var "shader")
           " is not a value generated by
\tOpenGL.")
     (para (code "GL_INVALID_OPERATION")
           " is generated if\t"
           (var "shader")
           " does not refer to a shader
\tobject.")
     (para (code "GL_INVALID_ENUM")
           " is generated if\t"
           (var "pname")
           " is not an accepted value.")
     (para (code "GL_INVALID_OPERATION")
           " is generated if\t"
           (code "glGetShader")
           " is executed between the
\texecution of\t"
           (code "glBegin")
           "
and the corresponding execution of\t"
           (code "glEnd")
           ".")))

(define-gl-procedure
  glGetString
  "glGetString"
  (funcsynopsis
    (funcprototype
      (funcdef
        "const GLubyte* "
        (function "glGetString"))
      (paramdef "GLenum " (parameter "name"))))
  '(*fragment*
     (heading
       "return a string describing the current GL connection")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "name")))
                   (para "
Specifies a symbolic constant, one of "
                         (code "GL_VENDOR")
                         ", "
                         (code "GL_RENDERER")
                         ", "
                         (code "GL_VERSION")
                         ", "
                         (code "GL_SHADING_LANGUAGE_VERSION")
                         ", or "
                         (code "GL_EXTENSIONS")
                         ". ")))
     (heading "Description")
     (para (code "glGetString")
           " returns a pointer to a static string
            describing some aspect of the current GL connection. "
           (var "name")
           " can be one of the following: ")
     (table (% (formatter (asis)))
            (entry (% (heading (code "GL_VENDOR")))
                   (para)
                   (para "
Returns the company responsible for this GL implementation.
                        This name does not change from release to release. "))
            (entry (% (heading (code "GL_RENDERER")))
                   (para)
                   (para "
Returns the name of the renderer.
                        This name is typically specific to a particular configuration of a hardware
                        platform.
                        It does not change from release to release. "))
            (entry (% (heading (code "GL_VERSION")))
                   (para)
                   (para "
Returns a version or release number. "))
            (entry (% (heading (code "GL_SHADING_LANGUAGE_VERSION")))
                   (para)
                   (para "
Returns a version or release number for the shading language. "))
            (entry (% (heading (code "GL_EXTENSIONS")))
                   (para)
                   (para "
Returns a space-separated list of supported extensions to GL. ")))
     (para "
Because the GL does not include queries for the performance
            characteristics of an implementation, some applications are written to
            recognize known platforms and modify their GL usage based on known
            performance characteristics of these platforms.
            Strings "
           (code "GL_VENDOR")
           " and "
           (code "GL_RENDERER")
           " together uniquely specify
            a platform. They do not change from release to release and should be used
            by platform-recognition algorithms. ")
     (para "
Some applications want to make use of features that
            are not part of the standard GL. These features
            may be implemented as extensions to the standard GL.
            The "
           (code "GL_EXTENSIONS")
           " string is a space-separated
            list of supported GL extensions.
            (Extension names never contain a space character.) ")
     (para "
The "
           (code "GL_VERSION")
           " and "
           (code "GL_SHADING_LANGUAGE_VERSION")
           " strings begin with a version number.
            The version number uses one
            of these forms: ")
     (para (var "major_number.minor_number")
           (var "major_number.minor_number.release_number"))
     (para "
Vendor-specific information may follow the version
            number. Its format depends on the implementation, but
            a space always separates the version number and
            the vendor-specific information. ")
     (para "
All strings are null-terminated. ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "name")
           " is not an accepted value. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glGetString")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glGetTexEnv
  "glGetTexEnv"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glGetTexEnvfv"))
      (paramdef "GLenum " (parameter "target"))
      (paramdef "GLenum " (parameter "pname"))
      (paramdef "GLfloat * " (parameter "params"))))
  '(*fragment*
     (heading "return texture environment parameters")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "target")))
                   (para "
Specifies a texture environment. May be "
                         (code "GL_TEXTURE_ENV")
                         ", "
                         (code "GL_TEXTURE_FILTER_CONTROL")
                         ", or "
                         (code "GL_POINT_SPRITE")
                         ". "))
            (entry (% (heading (var "pname")))
                   (para "
Specifies the symbolic name of a texture environment parameter.
                    Accepted values are "
                         (code "GL_TEXTURE_ENV_MODE")
                         ", "
                         (code "GL_TEXTURE_ENV_COLOR")
                         ", "
                         (code "GL_TEXTURE_LOD_BIAS")
                         ", "
                         (code "GL_COMBINE_RGB")
                         ", "
                         (code "GL_COMBINE_ALPHA")
                         ", "
                         (code "GL_SRC0_RGB")
                         ", "
                         (code "GL_SRC1_RGB")
                         ", "
                         (code "GL_SRC2_RGB")
                         ", "
                         (code "GL_SRC0_ALPHA")
                         ", "
                         (code "GL_SRC1_ALPHA")
                         ", "
                         (code "GL_SRC2_ALPHA")
                         ", "
                         (code "GL_OPERAND0_RGB")
                         ", "
                         (code "GL_OPERAND1_RGB")
                         ", "
                         (code "GL_OPERAND2_RGB")
                         ", "
                         (code "GL_OPERAND0_ALPHA")
                         ", "
                         (code "GL_OPERAND1_ALPHA")
                         ", "
                         (code "GL_OPERAND2_ALPHA")
                         ", "
                         (code "GL_RGB_SCALE")
                         ", "
                         (code "GL_ALPHA_SCALE")
                         ", or "
                         (code "GL_COORD_REPLACE")
                         ". "))
            (entry (% (heading (var "params")))
                   (para "
Returns the requested data. ")))
     (heading "Description")
     (para (code "glGetTexEnv")
           " returns in "
           (var "params")
           " selected values of a texture environment that
            was specified with "
           (code "glTexEnv")
           ". "
           (var "target")
           " specifies a texture environment. ")
     (para "
When "
           (var "target")
           " is "
           (code "GL_TEXTURE_FILTER_CONTROL")
           ", "
           (var "pname")
           " must be "
           (code "GL_TEXTURE_LOD_BIAS")
           ".  
            When "
           (var "target")
           " is "
           (code "GL_POINT_SPRITE")
           ", "
           (var "pname")
           " must be "
           (code "GL_COORD_REPLACE")
           ".
            When "
           (var "target")
           " is "
           (code "GL_TEXTURE_ENV")
           ", "
           (var "pname")
           " can be "
           (code "GL_TEXTURE_ENV_MODE")
           ", "
           (code "GL_TEXTURE_ENV_COLOR")
           ", "
           (code "GL_COMBINE_RGB")
           ", "
           (code "GL_COMBINE_ALPHA")
           ", "
           (code "GL_RGB_SCALE")
           ", "
           (code "GL_ALPHA_SCALE")
           ", "
           (code "GL_SRC0_RGB")
           ", "
           (code "GL_SRC1_RGB")
           ", "
           (code "GL_SRC2_RGB")
           ", "
           (code "GL_SRC0_ALPHA")
           ", "
           (code "GL_SRC1_ALPHA")
           ", or "
           (code "GL_SRC2_ALPHA")
           ". ")
     (para (var "pname")
           " names a specific texture environment parameter, as follows: ")
     (table (% (formatter (asis)))
            (entry (% (heading (code "GL_TEXTURE_ENV_MODE")))
                   (para (var "params")
                         " returns the single-valued texture environment mode,
                        a symbolic constant. The initial value is "
                         (code "GL_MODULATE")
                         ". "))
            (entry (% (heading (code "GL_TEXTURE_ENV_COLOR")))
                   (para (var "params")
                         " returns four integer or floating-point values that are the
                        texture environment color.
                        Integer values,
                        when requested,
                        are linearly mapped from the internal floating-point representation
                        such that 1.0 maps to the most positive representable integer,
                        and "
                         (math "-1.0")
                         "
maps to the most negative representable integer. The initial
                        value is (0, 0, 0, 0). "))
            (entry (% (heading (code "GL_TEXTURE_LOD_BIAS")))
                   (para (var "params")
                         " returns a single floating-point value that is the texture
                        level-of-detail bias.  The initial value is 0. "))
            (entry (% (heading (code "GL_COMBINE_RGB")))
                   (para (var "params")
                         " returns a single symbolic constant value representing the current
                        RGB combine mode.  The initial value is "
                         (code "GL_MODULATE")
                         ". "))
            (entry (% (heading (code "GL_COMBINE_ALPHA")))
                   (para (var "params")
                         " returns a single symbolic constant value representing the current
                        alpha combine mode.  The initial value is "
                         (code "GL_MODULATE")
                         ". "))
            (entry (% (heading (code "GL_SRC0_RGB")))
                   (para (var "params")
                         " returns a single symbolic constant value representing the texture
                        combiner zero's RGB source.  The initial value is "
                         (code "GL_TEXTURE")
                         ". "))
            (entry (% (heading (code "GL_SRC1_RGB")))
                   (para (var "params")
                         " returns a single symbolic constant value representing the texture
                        combiner one's RGB source.  The initial value is "
                         (code "GL_PREVIOUS")
                         ". "))
            (entry (% (heading (code "GL_SRC2_RGB")))
                   (para (var "params")
                         " returns a single symbolic constant value representing the texture
                        combiner two's RGB source.  The initial value is "
                         (code "GL_CONSTANT")
                         ". "))
            (entry (% (heading (code "GL_SRC0_ALPHA")))
                   (para (var "params")
                         " returns a single symbolic constant value representing the texture
                        combiner zero's alpha source.  The initial value is "
                         (code "GL_TEXTURE")
                         ". "))
            (entry (% (heading (code "GL_SRC1_ALPHA")))
                   (para (var "params")
                         " returns a single symbolic constant value representing the texture
                        combiner one's alpha source.  The initial value is "
                         (code "GL_PREVIOUS")
                         ". "))
            (entry (% (heading (code "GL_SRC2_ALPHA")))
                   (para (var "params")
                         " returns a single symbolic constant value representing the texture
                        combiner two's alpha source.  The initial value is "
                         (code "GL_CONSTANT")
                         ". "))
            (entry (% (heading (code "GL_OPERAND0_RGB")))
                   (para (var "params")
                         " returns a single symbolic constant value representing the texture
                        combiner zero's RGB operand.  The initial value is "
                         (code "GL_SRC_COLOR")
                         ". "))
            (entry (% (heading (code "GL_OPERAND1_RGB")))
                   (para (var "params")
                         " returns a single symbolic constant value representing the texture
                        combiner one's RGB operand.  The initial value is "
                         (code "GL_SRC_COLOR")
                         ". "))
            (entry (% (heading (code "GL_OPERAND2_RGB")))
                   (para (var "params")
                         " returns a single symbolic constant value representing the texture
                        combiner two's RGB operand.  The initial value is "
                         (code "GL_SRC_ALPHA")
                         ". "))
            (entry (% (heading (code "GL_OPERAND0_ALPHA")))
                   (para (var "params")
                         " returns a single symbolic constant value representing the texture
                        combiner zero's alpha operand.  The initial value is "
                         (code "GL_SRC_ALPHA")
                         ". "))
            (entry (% (heading (code "GL_OPERAND1_ALPHA")))
                   (para (var "params")
                         " returns a single symbolic constant value representing the texture
                        combiner one's alpha operand.  The initial value is "
                         (code "GL_SRC_ALPHA")
                         ". "))
            (entry (% (heading (code "GL_OPERAND2_ALPHA")))
                   (para (var "params")
                         " returns a single symbolic constant value representing the texture
                        combiner two's alpha operand.  The initial value is "
                         (code "GL_SRC_ALPHA")
                         ". "))
            (entry (% (heading (code "GL_RGB_SCALE")))
                   (para (var "params")
                         " returns a single floating-point value representing the current RGB
                        texture combiner scaling factor.  The initial value is 1.0. "))
            (entry (% (heading (code "GL_ALPHA_SCALE")))
                   (para (var "params")
                         " returns a single floating-point value representing the current alpha
                        texture combiner scaling factor.  The initial value is 1.0. "))
            (entry (% (heading (code "GL_COORD_REPLACE")))
                   (para (var "params")
                         " returns a single boolean value representing the current point sprite
                        texture coordinate replacement enable state.  The initial value is "
                         (code "GL_FALSE")
                         ". ")))
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "target")
           " or "
           (var "pname")
           " is not an
            accepted value. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glGetTexEnv")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glGetTexGen
  "glGetTexGen"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glGetTexGendv"))
      (paramdef "GLenum " (parameter "coord"))
      (paramdef "GLenum " (parameter "pname"))
      (paramdef "GLdouble * " (parameter "params"))))
  '(*fragment*
     (heading
       "return texture coordinate generation parameters")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "coord")))
                   (para "
Specifies a texture coordinate.
                    Must be "
                         (code "GL_S")
                         ", "
                         (code "GL_T")
                         ", "
                         (code "GL_R")
                         ", or "
                         (code "GL_Q")
                         ". "))
            (entry (% (heading (var "pname")))
                   (para "
Specifies the symbolic name of the value(s) to be returned.
                    Must be either "
                         (code "GL_TEXTURE_GEN_MODE")
                         "
or the name of one of the texture generation plane equations: "
                         (code "GL_OBJECT_PLANE")
                         " or "
                         (code "GL_EYE_PLANE")
                         ". "))
            (entry (% (heading (var "params")))
                   (para "
Returns the requested data. ")))
     (heading "Description")
     (para (code "glGetTexGen")
           " returns in "
           (var "params")
           " selected parameters of a texture coordinate
            generation function that was specified using "
           (code "glTexGen")
           ". "
           (var "coord")
           " names one of the ("
           (var "s")
           ", "
           (var "t")
           ", "
           (var "r")
           ", "
           (var "q")
           ")
            texture coordinates,
            using the symbolic constant "
           (code "GL_S")
           ", "
           (code "GL_T")
           ", "
           (code "GL_R")
           ", or "
           (code "GL_Q")
           ". ")
     (para (var "pname")
           " specifies one of three symbolic names: ")
     (table (% (formatter (asis)))
            (entry (% (heading (code "GL_TEXTURE_GEN_MODE")))
                   (para (var "params")
                         " returns the single-valued texture generation function,
                        a symbolic constant. The initial value is "
                         (code "GL_EYE_LINEAR")
                         ". "))
            (entry (% (heading (code "GL_OBJECT_PLANE")))
                   (para (var "params")
                         " returns the four plane equation coefficients that specify
                        object linear-coordinate generation.
                        Integer values, when requested,
                        are mapped directly from the internal floating-point representation. "))
            (entry (% (heading (code "GL_EYE_PLANE")))
                   (para (var "params")
                         " returns the four plane equation coefficients that specify
                        eye linear-coordinate generation.
                        Integer values,
                        when requested,
                        are mapped directly from the internal floating-point representation.
                        The returned values are those maintained in eye coordinates.
                        They are not equal to the values specified using "
                         (code "glTexGen")
                         ",
                        unless the modelview matrix was identity when "
                         (code "glTexGen")
                         " was called. ")))
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "coord")
           " or "
           (var "pname")
           " is not an
            accepted value. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glGetTexGen")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glGetTexImage
  "glGetTexImage"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glGetTexImage"))
      (paramdef "GLenum " (parameter "target"))
      (paramdef "GLint " (parameter "level"))
      (paramdef "GLenum " (parameter "format"))
      (paramdef "GLenum " (parameter "type"))
      (paramdef "GLvoid * " (parameter "img"))))
  '(*fragment*
     (heading "return a texture image")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "target")))
                   (para "
Specifies which texture is to be obtained. "
                         (code "GL_TEXTURE_1D")
                         ", "
                         (code "GL_TEXTURE_2D")
                         ", "
                         (code "GL_TEXTURE_3D")
                         ", "
                         (code "GL_TEXTURE_CUBE_MAP_POSITIVE_X")
                         ", "
                         (code "GL_TEXTURE_CUBE_MAP_NEGATIVE_X")
                         ", "
                         (code "GL_TEXTURE_CUBE_MAP_POSITIVE_Y")
                         ", "
                         (code "GL_TEXTURE_CUBE_MAP_NEGATIVE_Y")
                         ", "
                         (code "GL_TEXTURE_CUBE_MAP_POSITIVE_Z")
                         ", and "
                         (code "GL_TEXTURE_CUBE_MAP_NEGATIVE_Z")
                         " are accepted. "))
            (entry (% (heading (var "level")))
                   (para "
Specifies the level-of-detail number of the desired image.
                    Level 0 is the base image level.
                    Level "
                         (math (var "n"))
                         "
is the "
                         (math (var "n"))
                         "th
                    mipmap reduction image. "))
            (entry (% (heading (var "format")))
                   (para "
Specifies a pixel format for the returned data.
                    The supported formats are "
                         (code "GL_RED")
                         ", "
                         (code "GL_GREEN")
                         ", "
                         (code "GL_BLUE")
                         ", "
                         (code "GL_ALPHA")
                         ", "
                         (code "GL_RGB")
                         ", "
                         (code "GL_BGR")
                         ", "
                         (code "GL_RGBA")
                         ", "
                         (code "GL_BGRA")
                         ", "
                         (code "GL_LUMINANCE")
                         ", and "
                         (code "GL_LUMINANCE_ALPHA")
                         ". "))
            (entry (% (heading (var "type")))
                   (para "
Specifies a pixel type for the returned data.
                    The supported types are "
                         (code "GL_UNSIGNED_BYTE")
                         ", "
                         (code "GL_BYTE")
                         ", "
                         (code "GL_UNSIGNED_SHORT")
                         ", "
                         (code "GL_SHORT")
                         ", "
                         (code "GL_UNSIGNED_INT")
                         ", "
                         (code "GL_INT")
                         ", "
                         (code "GL_FLOAT")
                         ", "
                         (code "GL_UNSIGNED_BYTE_3_3_2")
                         ", "
                         (code "GL_UNSIGNED_BYTE_2_3_3_REV")
                         ", "
                         (code "GL_UNSIGNED_SHORT_5_6_5")
                         ", "
                         (code "GL_UNSIGNED_SHORT_5_6_5_REV")
                         ", "
                         (code "GL_UNSIGNED_SHORT_4_4_4_4")
                         ", "
                         (code "GL_UNSIGNED_SHORT_4_4_4_4_REV")
                         ", "
                         (code "GL_UNSIGNED_SHORT_5_5_5_1")
                         ", "
                         (code "GL_UNSIGNED_SHORT_1_5_5_5_REV")
                         ", "
                         (code "GL_UNSIGNED_INT_8_8_8_8")
                         ", "
                         (code "GL_UNSIGNED_INT_8_8_8_8_REV")
                         ", "
                         (code "GL_UNSIGNED_INT_10_10_10_2")
                         ", and "
                         (code "GL_UNSIGNED_INT_2_10_10_10_REV")
                         ". "))
            (entry (% (heading (var "img")))
                   (para "
Returns the texture image.
                    Should be a pointer to an array of the type specified by "
                         (var "type")
                         ". ")))
     (heading "Description")
     (para (code "glGetTexImage")
           " returns a texture image into "
           (var "img")
           ". "
           (var "target")
           " specifies whether the desired texture image is one specified by "
           (code "glTexImage1D")
           " ("
           (code "GL_TEXTURE_1D")
           "), "
           (code "glTexImage2D")
           " ("
           (code "GL_TEXTURE_2D")
           " or any of "
           (code "GL_TEXTURE_CUBE_MAP_*")
           "),
            or "
           (code "glTexImage3D")
           " ("
           (code "GL_TEXTURE_3D")
           "). "
           (var "level")
           " specifies the level-of-detail number of the desired image. "
           (var "format")
           " and "
           (var "type")
           " specify the format and type of the desired image array.
            See the reference pages "
           (code "glTexImage1D")
           " and "
           (code "glDrawPixels")
           "
for a description of the acceptable values for the "
           (var "format")
           " and "
           (var "type")
           "
parameters, respectively. ")
     (para "
If a non-zero named buffer object is bound to the "
           (code "GL_PIXEL_PACK_BUFFER")
           " target 
            (see "
           (code "glBindBuffer")
           ") while a texture image is
            requested, "
           (var "img")
           " is treated as a byte offset into the buffer object's data store. ")
     (para "
To understand the operation of "
           (code "glGetTexImage")
           ", consider the selected internal
            four-component texture image to be an RGBA color buffer the size of the image.
            The semantics of "
           (code "glGetTexImage")
           " are then identical to those of "
           (code "glReadPixels")
           ",
            with the exception that no pixel transfer operations are performed,
            when called with the same "
           (var "format")
           " and "
           (var "type")
           ",
            with "
           (var "x")
           " and "
           (var "y")
           " set to 0, "
           (var "width")
           " set to the width of the texture image
            (including border if one was specified),
            and "
           (var "height")
           " set to 1 for 1D images,
            or to the height of the texture image
            (including border if one was specified)
            for 2D images.
            Because the internal texture image is an RGBA image,
            pixel formats "
           (code "GL_COLOR_INDEX")
           ", "
           (code "GL_STENCIL_INDEX")
           ",
            and "
           (code "GL_DEPTH_COMPONENT")
           " are not accepted,
            and pixel type "
           (code "GL_BITMAP")
           " is not accepted. ")
     (para "
If the selected texture image does not contain four components,
            the following mappings are applied.
            Single-component textures are treated as RGBA buffers with red set
            to the single-component value,
            green set to 0, blue set to 0, and alpha set to 1.
            Two-component textures are treated as RGBA buffers with red set to
            the value of component zero,
            alpha set to the value of component one,
            and green and blue set to 0.
            Finally,
            three-component textures are treated as RGBA buffers with red set to
            component zero,
            green set to component one,
            blue set to component two,
            and alpha set to 1. ")
     (para "
To determine the required size of "
           (var "img")
           ",
            use "
           (code "glGetTexLevelParameter")
           " to determine the dimensions of the
            internal texture image,
            then scale the required number of pixels by the storage required for
            each pixel,
            based on "
           (var "format")
           " and "
           (var "type")
           ".
            Be sure to take the pixel storage parameters into account,
            especially "
           (code "GL_PACK_ALIGNMENT")
           ". ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "target")
           ", "
           (var "format")
           ", or "
           (var "type")
           " is not
            an accepted value. ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "level")
           " is less than 0. ")
     (para (code "GL_INVALID_VALUE")
           " may be generated if "
           (var "level")
           " is greater
            than "
           (math (var "log")
                 "_"
                 "2"
                 "\u2061"
                 "("
                 (var "max")
                 ","
                 ")")
           ",
            where "
           (math (var "max"))
           "
is the returned value of "
           (code "GL_MAX_TEXTURE_SIZE")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is returned if "
           (var "type")
           " is one of "
           (code "GL_UNSIGNED_BYTE_3_3_2")
           ", "
           (code "GL_UNSIGNED_BYTE_2_3_3_REV")
           ", "
           (code "GL_UNSIGNED_SHORT_5_6_5")
           ", or "
           (code "GL_UNSIGNED_SHORT_5_6_5_REV")
           " and "
           (var "format")
           " is not "
           (code "GL_RGB")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is returned if "
           (var "type")
           " is one of "
           (code "GL_UNSIGNED_SHORT_4_4_4_4")
           ", "
           (code "GL_UNSIGNED_SHORT_4_4_4_4_REV")
           ", "
           (code "GL_UNSIGNED_SHORT_5_5_5_1")
           ", "
           (code "GL_UNSIGNED_SHORT_1_5_5_5_REV")
           ", "
           (code "GL_UNSIGNED_INT_8_8_8_8")
           ", "
           (code "GL_UNSIGNED_INT_8_8_8_8_REV")
           ", "
           (code "GL_UNSIGNED_INT_10_10_10_2")
           ", or "
           (code "GL_UNSIGNED_INT_2_10_10_10_REV")
           ", and "
           (var "format")
           " is neither "
           (code "GL_RGBA")
           "
or "
           (code "GL_BGRA")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_PACK_BUFFER")
           " target and the buffer object's data store is currently mapped. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_PACK_BUFFER")
           " target and the data would be packed to the buffer 
            object such that the memory writes required would exceed the data store size. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_PACK_BUFFER")
           " target and "
           (var "img")
           " is not evenly divisible 
            into the number of bytes needed to store in memory a datum indicated by "
           (var "type")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glGetTexImage")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glGetTexLevelParameter
  "glGetTexLevelParameter"
  (funcsynopsis
    (funcprototype
      (funcdef
        "void "
        (function "glGetTexLevelParameterfv"))
      (paramdef "GLenum " (parameter "target"))
      (paramdef "GLint " (parameter "level"))
      (paramdef "GLenum " (parameter "pname"))
      (paramdef "GLfloat * " (parameter "params"))))
  '(*fragment*
     (heading
       "return texture parameter values for a specific level of detail")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "target")))
                   (para "
Specifies the symbolic name of the target texture,
                    either "
                         (code "GL_TEXTURE_1D")
                         ", "
                         (code "GL_TEXTURE_2D")
                         ", "
                         (code "GL_TEXTURE_3D")
                         ", "
                         (code "GL_PROXY_TEXTURE_1D")
                         ", "
                         (code "GL_PROXY_TEXTURE_2D")
                         ", "
                         (code "GL_PROXY_TEXTURE_3D")
                         ", "
                         (code "GL_TEXTURE_CUBE_MAP_POSITIVE_X")
                         ", "
                         (code "GL_TEXTURE_CUBE_MAP_NEGATIVE_X")
                         ", "
                         (code "GL_TEXTURE_CUBE_MAP_POSITIVE_Y")
                         ", "
                         (code "GL_TEXTURE_CUBE_MAP_NEGATIVE_Y")
                         ", "
                         (code "GL_TEXTURE_CUBE_MAP_POSITIVE_Z")
                         ", "
                         (code "GL_TEXTURE_CUBE_MAP_NEGATIVE_Z")
                         ", or "
                         (code "GL_PROXY_TEXTURE_CUBE_MAP")
                         ". "))
            (entry (% (heading (var "level")))
                   (para "
Specifies the level-of-detail number of the desired image.
                    Level 0 is the base image level.
                    Level "
                         (math (var "n"))
                         "
is the "
                         (math (var "n"))
                         "th
                    mipmap reduction image. "))
            (entry (% (heading (var "pname")))
                   (para "
Specifies the symbolic name of a texture parameter. "
                         (code "GL_TEXTURE_WIDTH")
                         ", "
                         (code "GL_TEXTURE_HEIGHT")
                         ", "
                         (code "GL_TEXTURE_DEPTH")
                         ", "
                         (code "GL_TEXTURE_INTERNAL_FORMAT")
                         ", "
                         (code "GL_TEXTURE_BORDER")
                         ", "
                         (code "GL_TEXTURE_RED_SIZE")
                         ", "
                         (code "GL_TEXTURE_GREEN_SIZE")
                         ", "
                         (code "GL_TEXTURE_BLUE_SIZE")
                         ", "
                         (code "GL_TEXTURE_ALPHA_SIZE")
                         ", "
                         (code "GL_TEXTURE_LUMINANCE_SIZE")
                         ", "
                         (code "GL_TEXTURE_INTENSITY_SIZE")
                         ", "
                         (code "GL_TEXTURE_DEPTH_SIZE")
                         ", "
                         (code "GL_TEXTURE_COMPRESSED")
                         ", and "
                         (code "GL_TEXTURE_COMPRESSED_IMAGE_SIZE")
                         "
are accepted. "))
            (entry (% (heading (var "params")))
                   (para "
Returns the requested data. ")))
     (heading "Description")
     (para (code "glGetTexLevelParameter")
           " returns in "
           (var "params")
           " texture parameter values for a specific
            level-of-detail value,
            specified as "
           (var "level")
           ". "
           (var "target")
           " defines the target texture,
            either "
           (code "GL_TEXTURE_1D")
           ", "
           (code "GL_TEXTURE_2D")
           ", "
           (code "GL_TEXTURE_3D")
           ", "
           (code "GL_PROXY_TEXTURE_1D")
           ", "
           (code "GL_PROXY_TEXTURE_2D")
           ", "
           (code "GL_PROXY_TEXTURE_3D")
           ", "
           (code "GL_TEXTURE_CUBE_MAP_POSITIVE_X")
           ", "
           (code "GL_TEXTURE_CUBE_MAP_NEGATIVE_X")
           ", "
           (code "GL_TEXTURE_CUBE_MAP_POSITIVE_Y")
           ", "
           (code "GL_TEXTURE_CUBE_MAP_NEGATIVE_Y")
           ", "
           (code "GL_TEXTURE_CUBE_MAP_POSITIVE_Z")
           ", "
           (code "GL_TEXTURE_CUBE_MAP_NEGATIVE_Z")
           ", or "
           (code "GL_PROXY_TEXTURE_CUBE_MAP")
           ". ")
     (para (code "GL_MAX_TEXTURE_SIZE")
           ", and "
           (code "GL_MAX_3D_TEXTURE_SIZE")
           " are not really
            descriptive enough.
            It has to report the largest square texture image that can be
            accommodated with mipmaps and borders,
            but a long skinny texture, or a texture without mipmaps and borders, may
            easily fit in texture memory.
            The proxy targets allow the user to more accurately query
            whether the GL can accommodate a texture of a given configuration.
            If the texture cannot be accommodated, the texture state variables, which
            may be queried with "
           (code "glGetTexLevelParameter")
           ", are set to 0.  If the texture can be accommodated,
            the texture state values will be set as they would be set for a
            non-proxy target. ")
     (para (var "pname")
           " specifies the texture parameter whose value or values
            will be returned. ")
     (para "
The accepted parameter names are as follows: ")
     (table (% (formatter (asis)))
            (entry (% (heading (code "GL_TEXTURE_WIDTH")))
                   (para)
                   (para (var "params")
                         " returns a single value,
                        the width of the texture image.
                        This value includes the border of the texture image. The initial value is
                        0. "))
            (entry (% (heading (code "GL_TEXTURE_HEIGHT")))
                   (para)
                   (para (var "params")
                         " returns a single value,
                        the height of the texture image.
                        This value includes the border of the texture image. The initial value is
                        0. "))
            (entry (% (heading (code "GL_TEXTURE_DEPTH")))
                   (para)
                   (para (var "params")
                         " returns a single value,
                        the depth of the texture image.
                        This value includes the border of the texture image. The initial value is
                        0. "))
            (entry (% (heading (code "GL_TEXTURE_INTERNAL_FORMAT")))
                   (para)
                   (para (var "params")
                         " returns a single value,
                        the internal format of the texture image. "))
            (entry (% (heading (code "GL_TEXTURE_BORDER")))
                   (para)
                   (para (var "params")
                         " returns a single value,
                        the width in pixels of the border of the texture image. The initial value
                        is 0. "))
            (entry (% (heading (code "GL_TEXTURE_RED_SIZE") ",")))
            (entry (% (heading (code "GL_TEXTURE_GREEN_SIZE") ",")))
            (entry (% (heading (code "GL_TEXTURE_BLUE_SIZE") ",")))
            (entry (% (heading (code "GL_TEXTURE_ALPHA_SIZE") ",")))
            (entry (% (heading (code "GL_TEXTURE_LUMINANCE_SIZE") ",")))
            (entry (% (heading (code "GL_TEXTURE_INTENSITY_SIZE") ",")))
            (entry (% (heading (code "GL_TEXTURE_DEPTH_SIZE")))
                   (para)
                   (para "
The internal storage resolution of an individual component.
                        The resolution chosen by the GL will be a close match for the resolution
                        requested by the user with the component argument of "
                         (code "glTexImage1D")
                         ", "
                         (code "glTexImage2D")
                         ", "
                         (code "glTexImage3D")
                         ", "
                         (code "glCopyTexImage1D")
                         ", and "
                         (code "glCopyTexImage2D")
                         ". The initial value is 0. "))
            (entry (% (heading (code "GL_TEXTURE_COMPRESSED")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating if the texture image is
                        stored in a compressed internal format.  The initiali value is "
                         (code "GL_FALSE")
                         ". "))
            (entry (% (heading
                        (code "GL_TEXTURE_COMPRESSED_IMAGE_SIZE")))
                   (para)
                   (para (var "params")
                         " returns a single integer value, the number of unsigned bytes of the
                        compressed texture image that would be returned from "
                         (code "glGetCompressedTexImage")
                         ". ")))
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "target")
           " or "
           (var "pname")
           " is not an
            accepted value. ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "level")
           " is less than 0. ")
     (para (code "GL_INVALID_VALUE")
           " may be generated if "
           (var "level")
           " is greater
            than "
           (math (var "log") "_" "2")
           (var "max")
           ",
            where "
           (var "max")
           " is the returned value of "
           (code "GL_MAX_TEXTURE_SIZE")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glGetTexLevelParameter")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "GL_TEXTURE_COMPRESSED_IMAGE_SIZE")
           " is queried on texture images with an
            uncompressed internal format or on proxy targets. ")))

(define-gl-procedure
  glGetTexParameter
  "glGetTexParameter"
  (funcsynopsis
    (funcprototype
      (funcdef
        "void "
        (function "glGetTexParameterfv"))
      (paramdef "GLenum " (parameter "target"))
      (paramdef "GLenum " (parameter "pname"))
      (paramdef "GLfloat * " (parameter "params"))))
  '(*fragment*
     (heading "return texture parameter values")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "target")))
                   (para "
Specifies the symbolic name of the target texture. "
                         (code "GL_TEXTURE_1D")
                         ", "
                         (code "GL_TEXTURE_2D")
                         ", "
                         (code "GL_TEXTURE_3D")
                         ", and "
                         (code "GL_TEXTURE_CUBE_MAP")
                         "
are accepted. "))
            (entry (% (heading (var "pname")))
                   (para "
Specifies the symbolic name of a texture parameter. "
                         (code "GL_TEXTURE_MAG_FILTER")
                         ", "
                         (code "GL_TEXTURE_MIN_FILTER")
                         ", "
                         (code "GL_TEXTURE_MIN_LOD")
                         ", "
                         (code "GL_TEXTURE_MAX_LOD")
                         ", "
                         (code "GL_TEXTURE_BASE_LEVEL")
                         ", "
                         (code "GL_TEXTURE_MAX_LEVEL")
                         ", "
                         (code "GL_TEXTURE_WRAP_S")
                         ", "
                         (code "GL_TEXTURE_WRAP_T")
                         ", "
                         (code "GL_TEXTURE_WRAP_R")
                         ", "
                         (code "GL_TEXTURE_BORDER_COLOR")
                         ", "
                         (code "GL_TEXTURE_PRIORITY")
                         ", "
                         (code "GL_TEXTURE_RESIDENT")
                         ", "
                         (code "GL_TEXTURE_COMPARE_MODE")
                         ", "
                         (code "GL_TEXTURE_COMPARE_FUNC")
                         ", "
                         (code "GL_DEPTH_TEXTURE_MODE")
                         ", and "
                         (code "GL_GENERATE_MIPMAP")
                         "
are accepted. "))
            (entry (% (heading (var "params")))
                   (para "
Returns the texture parameters. ")))
     (heading "Description")
     (para (code "glGetTexParameter")
           " returns in "
           (var "params")
           " the value or values of the texture parameter
            specified as "
           (var "pname")
           ". "
           (var "target")
           " defines the target texture,
            either "
           (code "GL_TEXTURE_1D")
           ", "
           (code "GL_TEXTURE_2D")
           ", "
           (code "GL_TEXTURE_3D")
           ", or "
           (code "GL_TEXTURE_CUBE_MAP")
           ",
            to specify one-, two-, or three-dimensional or cube-mapped texturing. "
           (var "pname")
           " accepts the same symbols as "
           (code "glTexParameter")
           ",
            with the same interpretations: ")
     (table (% (formatter (asis)))
            (entry (% (heading (code "GL_TEXTURE_MAG_FILTER")))
                   (para "
Returns the single-valued texture magnification filter,
                        a symbolic constant. The initial value is "
                         (code "GL_LINEAR")
                         ". "))
            (entry (% (heading (code "GL_TEXTURE_MIN_FILTER")))
                   (para "
Returns the single-valued texture minification filter,
                        a symbolic constant. The initial value is "
                         (code "GL_NEAREST_MIPMAP_LINEAR")
                         ". "))
            (entry (% (heading (code "GL_TEXTURE_MIN_LOD")))
                   (para "
Returns the single-valued texture minimum level-of-detail value.  The
                        initial value is "
                         (math "-1000")
                         ". "))
            (entry (% (heading (code "GL_TEXTURE_MAX_LOD")))
                   (para "
Returns the single-valued texture maximum level-of-detail value. The
                        initial value is 1000. "))
            (entry (% (heading (code "GL_TEXTURE_BASE_LEVEL")))
                   (para "
Returns the single-valued base texture mipmap level.  The initial value is 0. "))
            (entry (% (heading (code "GL_TEXTURE_MAX_LEVEL")))
                   (para "
Returns the single-valued maximum texture mipmap array level.  The initial
                        value is 1000. "))
            (entry (% (heading (code "GL_TEXTURE_WRAP_S")))
                   (para "
Returns the single-valued wrapping function for texture coordinate "
                         (math (var "s"))
                         ",
                        a symbolic constant. The initial value is "
                         (code "GL_REPEAT")
                         ". "))
            (entry (% (heading (code "GL_TEXTURE_WRAP_T")))
                   (para "
Returns the single-valued wrapping function for texture coordinate "
                         (math (var "t"))
                         ",
                        a symbolic constant. The initial value is "
                         (code "GL_REPEAT")
                         ". "))
            (entry (% (heading (code "GL_TEXTURE_WRAP_R")))
                   (para "
Returns the single-valued wrapping function for texture coordinate "
                         (math (var "r"))
                         ",
                        a symbolic constant. The initial value is "
                         (code "GL_REPEAT")
                         ". "))
            (entry (% (heading (code "GL_TEXTURE_BORDER_COLOR")))
                   (para "
Returns four integer or floating-point numbers that comprise the RGBA color
                        of the texture border.
                        Floating-point values are returned in the range "
                         (math "[" "0" "," "1" "]")
                         ".
                        Integer values are returned as a linear mapping of the internal floating-point
                        representation such that 1.0 maps to the most positive representable
                        integer and "
                         (math "-1.0")
                         "
maps to the most negative representable
                        integer. The initial value is (0, 0, 0, 0). "))
            (entry (% (heading (code "GL_TEXTURE_PRIORITY")))
                   (para "
Returns the residence priority of the target texture (or the named
                        texture bound to it). The initial value is 1.
                        See "
                         (code "glPrioritizeTextures")
                         ". "))
            (entry (% (heading (code "GL_TEXTURE_RESIDENT")))
                   (para "
Returns the residence status of the target texture.
                        If the value returned in "
                         (var "params")
                         " is "
                         (code "GL_TRUE")
                         ", the texture is
                        resident in texture memory.
                        See "
                         (code "glAreTexturesResident")
                         ". "))
            (entry (% (heading (code "GL_TEXTURE_COMPARE_MODE")))
                   (para "
Returns a single-valued texture comparison mode, a symbolic constant.  The
                        initial value is "
                         (code "GL_NONE")
                         ". See "
                         (code "glTexParameter")
                         ". "))
            (entry (% (heading (code "GL_TEXTURE_COMPARE_FUNC")))
                   (para "
Returns a single-valued texture comparison function, a symbolic constant.  The
                        initial value is "
                         (code "GL_LEQUAL")
                         ". See "
                         (code "glTexParameter")
                         ". "))
            (entry (% (heading (code "GL_DEPTH_TEXTURE_MODE")))
                   (para "
Returns a single-valued texture format indicating how the depth values
                        should be converted into color components.  The initial value is "
                         (code "GL_LUMINANCE")
                         ".  See "
                         (code "glTexParameter")
                         ". "))
            (entry (% (heading (code "GL_GENERATE_MIPMAP")))
                   (para "
Returns a single boolean value indicating if automatic mipmap level updates
                        are enabled.
                        See "
                         (code "glTexParameter")
                         ". ")))
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "target")
           " or "
           (var "pname")
           " is not an
            accepted value. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glGetTexParameter")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glGetUniformLocation
  "glGetUniformLocation"
  (funcsynopsis
    (funcprototype
      (funcdef
        "GLint "
        (function "glGetUniformLocation"))
      (paramdef "GLuint " (parameter "program"))
      (paramdef "const GLchar *" (parameter "name"))))
  '(*fragment*
     (heading
       "Returns the location of a uniform variable")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "program")))
                   (para "Specifies the program object to be
\t\t    queried."))
            (entry (% (heading (var "name")))
                   (para "Points to a null terminated string containing
\t\t    the name of the uniform variable whose location is
\t\t    to be queried.")))
     (heading "Description")
     (para (code "glGetUniformLocation ")
           " returns an
\tinteger that represents the location of a specific uniform
\tvariable within a program object. "
           (var "name")
           "
must be a null terminated string that contains no white space.\t"
           (var "name")
           " must be an active uniform variable
\tname in "
           (var "program")
           " that is not a structure,
\tan array of structures, or a subcomponent of a vector or a
\tmatrix. This function returns -1 if "
           (var "name")
           "
does not correspond to an active uniform variable in\t"
           (var "program")
           " or if "
           (var "name")
           "
starts with the reserved prefix \"gl_\".")
     (para "Uniform variables that are structures or arrays of
\tstructures may be queried by calling\t"
           (code "glGetUniformLocation")
           " for each field within
\tthe structure. The array element operator \"[]\" and the
\tstructure field operator \".\" may be used in\t"
           (var "name")
           " in order to select elements within
\tan array or fields within a structure. The result of using these
\toperators is not allowed to be another structure, an array of
\tstructures, or a subcomponent of a vector or a matrix. Except if
\tthe last part of "
           (var "name")
           " indicates a uniform
\tvariable array, the location of the first element of an array
\tcan be retrieved by using the name of the array, or by using the
\tname appended by \"[0]\".")
     (para "The actual locations assigned to uniform variables are not
\tknown until the program object is linked successfully. After
\tlinking has occurred, the command\t"
           (code "glGetUniformLocation")
           " can be used to obtain
\tthe location of a uniform variable. This location value can then
\tbe passed to\t"
           (code "glUniform")
           "
to set the value of the uniform variable or to\t"
           (code "glGetUniform")
           "
in order to query the current value of the uniform variable.
\tAfter a program object has been linked successfully, the index
\tvalues for uniform variables remain fixed until the next link
\tcommand occurs. Uniform variable locations and values can only
\tbe queried after a link if the link was successful.")
     (heading "Errors")
     (para (code "GL_INVALID_VALUE")
           " is generated if\t"
           (var "program")
           " is not a value generated by
\tOpenGL.")
     (para (code "GL_INVALID_OPERATION")
           " is generated if\t"
           (var "program")
           " is not a program object.")
     (para (code "GL_INVALID_OPERATION")
           " is generated if\t"
           (var "program")
           " has not been successfully
\tlinked.")
     (para (code "GL_INVALID_OPERATION")
           " is generated if\t"
           (code "glGetUniformLocation")
           " is executed between
\tthe execution of\t"
           (code "glBegin")
           "
and the corresponding execution of\t"
           (code "glEnd")
           ".")))

(define-gl-procedure
  glGetUniformfv
  "glGetUniformfv"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glGetUniformfv"))
      (paramdef "GLuint " (parameter "program"))
      (paramdef "GLint " (parameter "location"))
      (paramdef "GLfloat *" (parameter "params")))
    (funcprototype
      (funcdef "void " (function "glGetUniformiv"))
      (paramdef "GLuint " (parameter "program"))
      (paramdef "GLint " (parameter "location"))
      (paramdef "GLint *" (parameter "params"))))
  '(*fragment*
     (heading
       "Returns the value of a uniform variable")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "program")))
                   (para "Specifies the program object to be
\t\t    queried."))
            (entry (% (heading (var "location")))
                   (para "Specifies the location of the uniform variable
\t\t    to be queried."))
            (entry (% (heading (var "params")))
                   (para "Returns the value of the specified uniform
\t\t    variable.")))
     (heading "Description")
     (para (code "glGetUniform")
           " returns in\t"
           (var "params")
           " the value(s) of the specified
\tuniform variable. The type of the uniform variable specified by\t"
           (var "location")
           " determines the number of values
\treturned. If the uniform variable is defined in the shader as a
\tboolean, int, or float, a single value will be returned. If it
\tis defined as a vec2, ivec2, or bvec2, two values will be
\treturned. If it is defined as a vec3, ivec3, or bvec3, three
\tvalues will be returned, and so on. To query values stored in
\tuniform variables declared as arrays, call\t"
           (code "glGetUniform")
           " for each element of the array.
\tTo query values stored in uniform variables declared as
\tstructures, call "
           (code "glGetUniform")
           " for each
\tfield in the structure. The values for uniform variables
\tdeclared as a matrix will be returned in column major
\torder.")
     (para "The locations assigned to uniform variables are not known
\tuntil the program object is linked. After linking has occurred,
\tthe command\t"
           (code "glGetUniformLocation")
           "
can be used to obtain the location of a uniform variable. This
\tlocation value can then be passed to\t"
           (code "glGetUniform")
           " in order to query the current
\tvalue of the uniform variable. After a program object has been
\tlinked successfully, the index values for uniform variables
\tremain fixed until the next link command occurs. The uniform
\tvariable values can only be queried after a link if the link was
\tsuccessful.")
     (heading "Errors")
     (para (code "GL_INVALID_VALUE")
           " is generated if\t"
           (var "program")
           " is not a value generated by
\tOpenGL.")
     (para (code "GL_INVALID_OPERATION")
           " is generated if\t"
           (var "program")
           " is not a program object.")
     (para (code "GL_INVALID_OPERATION")
           " is generated if\t"
           (var "program")
           " has not been successfully
\tlinked.")
     (para (code "GL_INVALID_OPERATION")
           " is generated if\t"
           (var "location")
           " does not correspond to a valid
\tuniform variable location for the specified program object.")
     (para (code "GL_INVALID_OPERATION")
           " is generated if\t"
           (code "glGetUniform")
           " is executed between the
\texecution of\t"
           (code "glBegin")
           "
and the corresponding execution of\t"
           (code "glEnd")
           ".")))

(define-gl-procedure
  glGetVertexAttribPointerv
  "glGetVertexAttribPointerv"
  (funcsynopsis
    (funcprototype
      (funcdef
        "void "
        (function "glGetVertexAttribPointerv"))
      (paramdef "GLuint " (parameter "index"))
      (paramdef "GLenum " (parameter "pname"))
      (paramdef "GLvoid **" (parameter "pointer"))))
  '(*fragment*
     (heading
       "return the address of the specified generic vertex attribute pointer")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "index")))
                   (para "Specifies the generic vertex attribute
\t\t    parameter to be returned."))
            (entry (% (heading (var "pname")))
                   (para "Specifies the symbolic name of the generic
\t\t    vertex attribute parameter to be returned. Must be "
                         (code "GL_VERTEX_ATTRIB_ARRAY_POINTER")
                         "."))
            (entry (% (heading (var "pointer")))
                   (para "Returns the pointer value.")))
     (heading "Description")
     (para (code "glGetVertexAttribPointerv")
           " returns
\tpointer information. "
           (var "index")
           " is the generic
\tvertex attribute to be queried, "
           (var "pname")
           " is
\ta symbolic constant indicating the pointer to be returned, and\t"
           (var "params")
           " is a pointer to a location in
\twhich to place the returned data.")
     (para "If a non-zero named buffer object was bound to the "
           (code "GL_ARRAY_BUFFER")
           " target 
        (see "
           (code "glBindBuffer")
           ") when the desired pointer was previously
        specified, the "
           (var "pointer")
           " returned is a byte offset into the buffer object's data store. ")
     (heading "Errors")
     (para (code "GL_INVALID_VALUE")
           "
is generated if "
           (var "index")
           "
is greater than or equal to "
           (code "GL_MAX_VERTEX_ATTRIBS")
           ".")
     (para (code "GL_INVALID_ENUM")
           "
is generated if "
           (var "pname")
           "
is not an accepted value.")))

(define-gl-procedure
  glGetVertexAttribdv
  "glGetVertexAttribdv"
  (funcsynopsis
    (funcprototype
      (funcdef
        "void "
        (function "glGetVertexAttribdv"))
      (paramdef "GLuint " (parameter "index"))
      (paramdef "GLenum " (parameter "pname"))
      (paramdef "GLdouble *" (parameter "params")))
    (funcprototype
      (funcdef
        "void "
        (function "glGetVertexAttribfv"))
      (paramdef "GLuint " (parameter "index"))
      (paramdef "GLenum " (parameter "pname"))
      (paramdef "GLfloat *" (parameter "params")))
    (funcprototype
      (funcdef
        "void "
        (function "glGetVertexAttribiv"))
      (paramdef "GLuint " (parameter "index"))
      (paramdef "GLenum " (parameter "pname"))
      (paramdef "GLint *" (parameter "params"))))
  '(*fragment*
     (heading
       "Return a generic vertex attribute parameter")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "index")))
                   (para "Specifies the generic vertex attribute
\t\t    parameter to be queried."))
            (entry (% (heading (var "pname")))
                   (para "Specifies the symbolic name of the vertex
\t\t    attribute parameter to be queried. Accepted values are "
                         (code "GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING")
                         ", "
                         (code "GL_VERTEX_ATTRIB_ARRAY_ENABLED")
                         ", "
                         (code "GL_VERTEX_ATTRIB_ARRAY_SIZE")
                         ", "
                         (code "GL_VERTEX_ATTRIB_ARRAY_STRIDE")
                         ", "
                         (code "GL_VERTEX_ATTRIB_ARRAY_TYPE")
                         ", "
                         (code "GL_VERTEX_ATTRIB_ARRAY_NORMALIZED")
                         ", or "
                         (code "GL_CURRENT_VERTEX_ATTRIB")
                         "."))
            (entry (% (heading (var "params")))
                   (para "Returns the requested data.")))
     (heading "Description")
     (para (code "glGetVertexAttrib")
           " returns in\t"
           (var "params")
           " the value of a generic vertex
\tattribute parameter. The generic vertex attribute to be queried
\tis specified by "
           (var "index")
           ", and the parameter
\tto be queried is specified by "
           (var "pname")
           ".")
     (para "The accepted parameter names are as follows:")
     (table (% (formatter (asis)))
            (entry (% (heading
                        (code "GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING")))
                   (para)
                   (para (var "params")
                         " returns a
\t\t    single value, the name of the buffer object currently bound to
                    the binding point corresponding to generic vertex attribute array "
                         (var "index")
                         ". If no buffer object is bound, 
                    0 is returned. The initial value is 0."))
            (entry (% (heading (code "GL_VERTEX_ATTRIB_ARRAY_ENABLED")))
                   (para)
                   (para (var "params")
                         " returns a
\t\t    single value that is non-zero (true) if the vertex
\t\t    attribute array for "
                         (var "index")
                         " is
\t\t    enabled and 0 (false) if it is disabled. The initial
\t\t    value is "
                         (code "GL_FALSE")
                         "."))
            (entry (% (heading (code "GL_VERTEX_ATTRIB_ARRAY_SIZE")))
                   (para)
                   (para (var "params")
                         " returns a
\t\t    single value, the size of the vertex attribute array
\t\t    for "
                         (var "index")
                         ". The size is the
\t\t    number of values for each element of the vertex
\t\t    attribute array, and it will be 1, 2, 3, or 4. The
\t\t    initial value is 4."))
            (entry (% (heading (code "GL_VERTEX_ATTRIB_ARRAY_STRIDE")))
                   (para)
                   (para (var "params")
                         " returns a
\t\t    single value, the array stride for (number of bytes
\t\t    between successive elements in) the vertex attribute
\t\t    array for "
                         (var "index")
                         ". A value of 0
\t\t    indicates that the array elements are stored
\t\t    sequentially in memory. The initial value is 0."))
            (entry (% (heading (code "GL_VERTEX_ATTRIB_ARRAY_TYPE")))
                   (para)
                   (para (var "params")
                         " returns a
\t\t    single value, a symbolic constant indicating the
\t\t    array type for the vertex attribute array for "
                         (var "index")
                         ". Possible values are "
                         (code "GL_BYTE")
                         ", "
                         (code "GL_UNSIGNED_BYTE")
                         ", "
                         (code "GL_SHORT")
                         ", "
                         (code "GL_UNSIGNED_SHORT")
                         ", "
                         (code "GL_INT")
                         ", "
                         (code "GL_UNSIGNED_INT")
                         ", "
                         (code "GL_FLOAT")
                         ", and "
                         (code "GL_DOUBLE")
                         ". The initial value is "
                         (code "GL_FLOAT")
                         "."))
            (entry (% (heading
                        (code "GL_VERTEX_ATTRIB_ARRAY_NORMALIZED")))
                   (para)
                   (para (var "params")
                         " returns a
\t\t    single value that is non-zero (true) if fixed-point
\t\t    data types for the vertex attribute array indicated
\t\t    by "
                         (var "index")
                         " are normalized when
\t\t    they are converted to floating point, and 0 (false)
\t\t    otherwise. The initial value is "
                         (code "GL_FALSE")
                         "."))
            (entry (% (heading (code "GL_CURRENT_VERTEX_ATTRIB")))
                   (para)
                   (para (var "params")
                         " returns four
\t\t    values that represent the current value for the
\t\t    generic vertex attribute specified by index. Generic
\t\t    vertex attribute 0 is unique in that it has no
\t\t    current state, so an error will be generated if "
                         (var "index")
                         " is 0. The initial value
\t\t    for all other generic vertex attributes is
\t\t    (0,0,0,1).")))
     (para "All of the parameters except "
           (code "GL_CURRENT_VERTEX_ATTRIB")
           "
represent client-side state.")
     (heading "Errors")
     (para (code "GL_INVALID_VALUE")
           " is generated if\t"
           (var "index")
           " is greater than or equal to\t"
           (code "GL_MAX_VERTEX_ATTRIBS")
           ".")
     (para (code "GL_INVALID_ENUM")
           " is generated if\t"
           (var "pname")
           " is not an accepted value.")
     (para (code "GL_INVALID_OPERATION")
           " is generated if\t"
           (var "index")
           " is 0 and\t"
           (var "pname")
           " is\t"
           (code "GL_CURRENT_VERTEX_ATTRIB")
           ".")))

(define-gl-procedure
  glGet
  "glGet"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glGetBooleanv"))
      (paramdef "GLenum " (parameter "pname"))
      (paramdef "GLboolean * " (parameter "params"))))
  '(*fragment*
     (heading
       "return the value or values of a selected parameter")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "pname")))
                   (para "
Specifies the parameter value to be returned.
                    The symbolic constants in the list below are accepted. "))
            (entry (% (heading (var "params")))
                   (para "
Returns the value or values of the specified parameter. ")))
     (heading "Description")
     (para "
These four commands return values for simple state variables in GL. "
           (var "pname")
           " is a symbolic constant indicating the state variable to be returned,
            and "
           (var "params")
           " is a pointer to an array of the indicated type in
            which to place the returned data. ")
     (para "
Type conversion is performed if "
           (var "params")
           " has a different type than
            the state variable value being requested.
            If "
           (code "glGetBooleanv")
           " is called,
            a floating-point (or integer) value is converted to "
           (code "GL_FALSE")
           " if
            and only if it is 0.0 (or 0).
            Otherwise,
            it is converted to "
           (code "GL_TRUE")
           ".
            If "
           (code "glGetIntegerv")
           " is called, boolean values are returned as "
           (code "GL_TRUE")
           " or "
           (code "GL_FALSE")
           ", and most floating-point values are
            rounded to the nearest integer value. Floating-point colors and
            normals, however, are returned with a linear mapping that maps 1.0 to
            the most positive representable integer value
            and "
           (math "-1.0")
           "
to the most negative representable integer value.
            If "
           (code "glGetFloatv")
           " or "
           (code "glGetDoublev")
           " is called,
            boolean values are returned as "
           (code "GL_TRUE")
           " or "
           (code "GL_FALSE")
           ",
            and integer values are converted to floating-point values. ")
     (para "
The following symbolic constants are accepted by "
           (var "pname")
           ": ")
     (table (% (formatter (asis)))
            (entry (% (heading (code "GL_ACCUM_ALPHA_BITS")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the number of alpha bitplanes in the accumulation buffer. "))
            (entry (% (heading (code "GL_ACCUM_BLUE_BITS")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the number of blue bitplanes in the accumulation buffer. "))
            (entry (% (heading (code "GL_ACCUM_CLEAR_VALUE")))
                   (para)
                   (para (var "params")
                         " returns four values:
                        the red, green, blue, and alpha values used to clear the accumulation buffer.
                        Integer values,
                        if requested,
                        are linearly mapped from the internal floating-point representation such
                        that 1.0 returns the most positive representable integer value,
                        and "
                         (math "-1.0")
                         "
returns the most negative representable integer
                        value. The initial value is (0, 0, 0, 0).
                        See "
                         (code "glClearAccum")
                         ". "))
            (entry (% (heading (code "GL_ACCUM_GREEN_BITS")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the number of green bitplanes in the accumulation buffer. "))
            (entry (% (heading (code "GL_ACCUM_RED_BITS")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the number of red bitplanes in the accumulation buffer. "))
            (entry (% (heading (code "GL_ACTIVE_TEXTURE")))
                   (para)
                   (para (var "params")
                         " returns a single value indicating the active multitexture unit.
                        The initial value is "
                         (code "GL_TEXTURE0")
                         ".
                        See "
                         (code "glActiveTexture")
                         ". "))
            (entry (% (heading (code "GL_ALIASED_POINT_SIZE_RANGE")))
                   (para)
                   (para (var "params")
                         " returns two values,
                        the smallest and largest supported sizes for aliased points. "))
            (entry (% (heading (code "GL_ALIASED_LINE_WIDTH_RANGE")))
                   (para)
                   (para (var "params")
                         " returns two values,
                        the smallest and largest supported widths for aliased lines. "))
            (entry (% (heading (code "GL_ALPHA_BIAS")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the alpha bias factor used during pixel transfers. The initial value is 0.
                        See "
                         (code "glPixelTransfer")
                         ". "))
            (entry (% (heading (code "GL_ALPHA_BITS")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the number of alpha bitplanes in each color buffer. "))
            (entry (% (heading (code "GL_ALPHA_SCALE")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the alpha scale factor used
                        during pixel transfers. The initial value is 1.
                        See "
                         (code "glPixelTransfer")
                         ". "))
            (entry (% (heading (code "GL_ALPHA_TEST")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether alpha testing
                        of fragments is enabled. The initial value is "
                         (code "GL_FALSE")
                         ".
                        See "
                         (code "glAlphaFunc")
                         ". "))
            (entry (% (heading
                        (code "GL_ALPHA_TEST_FUNC")
                        (var "params")
                        " returns one value,"))
                   (para)
                   (para "
the symbolic name of the alpha test function. The initial value is "
                         (code "GL_ALWAYS")
                         ".
                        See "
                         (code "glAlphaFunc")
                         ". "))
            (entry (% (heading (code "GL_ALPHA_TEST_REF")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the reference value for the alpha test. The initial value is 0.
                        See "
                         (code "glAlphaFunc")
                         ".
                        An integer value,
                        if requested,
                        is linearly mapped from the internal floating-point representation such
                        that 1.0 returns the most positive representable integer value,
                        and "
                         (math "-1.0")
                         "
returns the most negative representable integer value. "))
            (entry (% (heading (code "GL_ARRAY_BUFFER_BINDING")))
                   (para)
                   (para (var "params")
                         " returns a single value, the name of the buffer object
                        currently bound to the target "
                         (code "GL_ARRAY_BUFFER")
                         ". If no buffer object
                        is bound to this target, 0 is returned.  The initial value is 0.
                        See "
                         (code "glBindBuffer")
                         ". "))
            (entry (% (heading (code "GL_ATTRIB_STACK_DEPTH")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the depth of the attribute stack.
                        If the stack is empty,
                        0 is returned. The initial value is 0.
                        See "
                         (code "glPushAttrib")
                         ". "))
            (entry (% (heading (code "GL_AUTO_NORMAL")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether 2D map evaluation
                        automatically generates surface normals. The initial value is "
                         (code "GL_FALSE")
                         ".
                        See "
                         (code "glMap2")
                         ". "))
            (entry (% (heading (code "GL_AUX_BUFFERS")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the number of auxiliary color buffers available. "))
            (entry (% (heading (code "GL_BLEND")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether blending is
                        enabled. The initial value is "
                         (code "GL_FALSE")
                         ".
                        See "
                         (code "glBlendFunc")
                         ". "))
            (entry (% (heading (code "GL_BLEND_COLOR")))
                   (para)
                   (para (var "params")
                         " returns four values,
                        the red, green, blue, and alpha values which are the components of
                        the blend color.
                        See "
                         (code "glBlendColor")
                         ". "))
            (entry (% (heading (code "GL_BLEND_DST_ALPHA")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the symbolic constant identifying the alpha destination blend
                        function. The initial value is "
                         (code "GL_ZERO")
                         ".
                        See "
                         (code "glBlendFunc")
                         " and "
                         (code "glBlendFuncSeparate")
                         ". "))
            (entry (% (heading (code "GL_BLEND_DST_RGB")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the symbolic constant identifying the RGB destination blend
                        function. The initial value is "
                         (code "GL_ZERO")
                         ".
                        See "
                         (code "glBlendFunc")
                         " and "
                         (code "glBlendFuncSeparate")
                         ". "))
            (entry (% (heading (code "GL_BLEND_EQUATION_RGB")))
                   (para)
                   (para (var "params")
                         " returns one value, a symbolic constant indicating whether
                        the RGB blend equation is "
                         (code "GL_FUNC_ADD")
                         ", "
                         (code "GL_FUNC_SUBTRACT")
                         ", "
                         (code "GL_FUNC_REVERSE_SUBTRACT")
                         ", "
                         (code "GL_MIN")
                         " or "
                         (code "GL_MAX")
                         ".
                        See "
                         (code "glBlendEquationSeparate")
                         ". "))
            (entry (% (heading (code "GL_BLEND_EQUATION_ALPHA")))
                   (para)
                   (para (var "params")
                         " returns one value, a symbolic constant indicating whether
                        the Alpha blend equation is "
                         (code "GL_FUNC_ADD")
                         ", "
                         (code "GL_FUNC_SUBTRACT")
                         ", "
                         (code "GL_FUNC_REVERSE_SUBTRACT")
                         ", "
                         (code "GL_MIN")
                         " or "
                         (code "GL_MAX")
                         ".
                        See "
                         (code "glBlendEquationSeparate")
                         ". "))
            (entry (% (heading (code "GL_BLEND_SRC_ALPHA")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the symbolic constant identifying the alpha source blend function. The initial
                        value is "
                         (code "GL_ONE")
                         ".
                        See "
                         (code "glBlendFunc")
                         " and "
                         (code "glBlendFuncSeparate")
                         ". "))
            (entry (% (heading (code "GL_BLEND_SRC_RGB")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the symbolic constant identifying the RGB source blend function. The initial
                        value is "
                         (code "GL_ONE")
                         ".
                        See "
                         (code "glBlendFunc")
                         " and "
                         (code "glBlendFuncSeparate")
                         ". "))
            (entry (% (heading (code "GL_BLUE_BIAS")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the blue bias factor used during pixel transfers. The initial value is 0.
                        See "
                         (code "glPixelTransfer")
                         ". "))
            (entry (% (heading (code "GL_BLUE_BITS")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the number of blue bitplanes in each color buffer. "))
            (entry (% (heading (code "GL_BLUE_SCALE")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the blue scale factor used during pixel transfers. The initial value is 1.
                        See "
                         (code "glPixelTransfer")
                         ". "))
            (entry (% (heading (code "GL_CLIENT_ACTIVE_TEXTURE")))
                   (para)
                   (para (var "params")
                         " returns a single integer value indicating the current client active
                        multitexture unit. The initial value is "
                         (code "GL_TEXTURE0")
                         ".
                        See "
                         (code "glClientActiveTexture")
                         ". "))
            (entry (% (heading (code "GL_CLIENT_ATTRIB_STACK_DEPTH")))
                   (para)
                   (para (var "params")
                         " returns one value indicating the depth of the
                        attribute stack. The initial value is 0.
                        See "
                         (code "glPushClientAttrib")
                         ". "))
            (entry (% (heading (code "GL_CLIP_PLANE") (var "i")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether the specified
                        clipping plane is enabled. The initial value is "
                         (code "GL_FALSE")
                         ".
                        See "
                         (code "glClipPlane")
                         ". "))
            (entry (% (heading (code "GL_COLOR_ARRAY")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether the color array is enabled. The initial value is "
                         (code "GL_FALSE")
                         ".
                        See "
                         (code "glColorPointer")
                         ". "))
            (entry (% (heading (code "GL_COLOR_ARRAY_BUFFER_BINDING")))
                   (para)
                   (para (var "params")
                         " returns a single value, the name of the buffer object
                        associated with the color array. This buffer object would have been bound to the 
                        target "
                         (code "GL_ARRAY_BUFFER")
                         " at the time of the most recent call to "
                         (code "glColorPointer")
                         ". 
                        If no buffer object was bound to this target, 0 is returned.  The initial value is 0.
                        See "
                         (code "glBindBuffer")
                         ". "))
            (entry (% (heading (code "GL_COLOR_ARRAY_SIZE")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the number of components per color in the color array. The initial value
                        is 4.
                        See "
                         (code "glColorPointer")
                         ". "))
            (entry (% (heading (code "GL_COLOR_ARRAY_STRIDE")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the byte offset between consecutive colors in the color array. The initial
                        value is 0.
                        See "
                         (code "glColorPointer")
                         ". "))
            (entry (% (heading (code "GL_COLOR_ARRAY_TYPE")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the data type of each component in the color array. The initial value
                        is "
                         (code "GL_FLOAT")
                         ".
                        See "
                         (code "glColorPointer")
                         ". "))
            (entry (% (heading (code "GL_COLOR_CLEAR_VALUE")))
                   (para)
                   (para (var "params")
                         " returns four values:
                        the red, green, blue, and alpha values used to clear the color buffers.
                        Integer values,
                        if requested,
                        are linearly mapped from the internal floating-point representation such
                        that 1.0 returns the most positive representable integer value,
                        and "
                         (math "-1.0")
                         "
returns the most negative representable integer
                        value. The initial value is (0, 0, 0, 0).
                        See "
                         (code "glClearColor")
                         ". "))
            (entry (% (heading (code "GL_COLOR_LOGIC_OP")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether a fragment's
                        RGBA color values are merged into the framebuffer using a logical
                        operation. The initial value is "
                         (code "GL_FALSE")
                         ".
                        See "
                         (code "glLogicOp")
                         ". "))
            (entry (% (heading (code "GL_COLOR_MATERIAL")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether one or more
                        material parameters are tracking the current color. The initial value
                        is "
                         (code "GL_FALSE")
                         ".
                        See "
                         (code "glColorMaterial")
                         ". "))
            (entry (% (heading (code "GL_COLOR_MATERIAL_FACE")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        a symbolic constant indicating which materials have a parameter that is
                        tracking the current color. The initial value is "
                         (code "GL_FRONT_AND_BACK")
                         ".
                        See "
                         (code "glColorMaterial")
                         ". "))
            (entry (% (heading (code "GL_COLOR_MATERIAL_PARAMETER")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        a symbolic constant indicating which material parameters are
                        tracking the current color. The initial value is "
                         (code "GL_AMBIENT_AND_DIFFUSE")
                         ".
                        See "
                         (code "glColorMaterial")
                         ". "))
            (entry (% (heading (code "GL_COLOR_MATRIX")))
                   (para)
                   (para (var "params")
                         " returns sixteen values:
                        the color matrix on the top of the color matrix stack. Initially
                        this matrix is the identity matrix.
                        See "
                         (code "glPushMatrix")
                         ". "))
            (entry (% (heading (code "GL_COLOR_MATRIX_STACK_DEPTH")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the maximum supported depth of the projection matrix stack. The value must
                        be at least 2.
                        See "
                         (code "glPushMatrix")
                         ". "))
            (entry (% (heading (code "GL_COLOR_SUM")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether primary and
                        secondary color sum is enabled.
                        See "
                         (code "glSecondaryColor")
                         ". "))
            (entry (% (heading (code "GL_COLOR_TABLE")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether the color table
                        lookup is enabled.
                        See "
                         (code "glColorTable")
                         ". "))
            (entry (% (heading (code "GL_COLOR_WRITEMASK")))
                   (para)
                   (para (var "params")
                         " returns four boolean values:
                        the red, green, blue, and alpha write enables for the color
                        buffers. The initial value is ("
                         (code "GL_TRUE")
                         ", "
                         (code "GL_TRUE")
                         ", "
                         (code "GL_TRUE")
                         ", "
                         (code "GL_TRUE")
                         ").
                        See "
                         (code "glColorMask")
                         ". "))
            (entry (% (heading (code "GL_COMPRESSED_TEXTURE_FORMATS")))
                   (para)
                   (para (var "params")
                         " returns a list of symbolic
                        constants of length "
                         (code "GL_NUM_COMPRESSED_TEXTURE_FORMATS")
                         " indicating which compressed texture formats are available.
                        See "
                         (code "glCompressedTexImage2D")
                         ". "))
            (entry (% (heading (code "GL_CONVOLUTION_1D")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether 1D convolution
                        is enabled. The initial value is "
                         (code "GL_FALSE")
                         ".
                        See "
                         (code "glConvolutionFilter1D")
                         ". "))
            (entry (% (heading (code "GL_CONVOLUTION_2D")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether 2D convolution
                        is enabled. The initial value is "
                         (code "GL_FALSE")
                         ".
                        See "
                         (code "glConvolutionFilter2D")
                         ". "))
            (entry (% (heading (code "GL_CULL_FACE")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether polygon culling
                        is enabled. The initial value is "
                         (code "GL_FALSE")
                         ".
                        See "
                         (code "glCullFace")
                         ". "))
            (entry (% (heading (code "GL_CULL_FACE_MODE")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        a symbolic constant indicating which polygon faces are to be
                        culled. The initial value is "
                         (code "GL_BACK")
                         ".
                        See "
                         (code "glCullFace")
                         ". "))
            (entry (% (heading (code "GL_CURRENT_COLOR")))
                   (para)
                   (para (var "params")
                         " returns four values:
                        the red, green, blue, and alpha values of the current color.
                        Integer values,
                        if requested,
                        are linearly mapped from the internal floating-point representation such
                        that 1.0 returns the most positive representable integer value,
                        and "
                         (math "-1.0")
                         "
returns the most negative representable integer value.
                        The initial value is (1, 1, 1, 1).
                        See "
                         (code "glColor")
                         ". "))
            (entry (% (heading (code "GL_CURRENT_FOG_COORD")))
                   (para)
                   (para (var "params")
                         " returns one value, the current fog coordinate.  The initial value
                        is 0.
                        See "
                         (code "glFogCoord")
                         ". "))
            (entry (% (heading (code "GL_CURRENT_INDEX")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the current color index. The initial value is 1.
                        See "
                         (code "glIndex")
                         ". "))
            (entry (% (heading (code "GL_CURRENT_NORMAL")))
                   (para)
                   (para (var "params")
                         " returns three values:
                        the "
                         (var "x")
                         ", "
                         (var "y")
                         ", and "
                         (var "z")
                         " values of the current normal.
                        Integer values,
                        if requested,
                        are linearly mapped from the internal floating-point representation such
                        that 1.0 returns the most positive representable integer value,
                        and "
                         (math "-1.0")
                         "
returns the most negative representable integer value.
                        The initial value is (0, 0, 1).
                        See "
                         (code "glNormal")
                         ". "))
            (entry (% (heading (code "GL_CURRENT_PROGRAM")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the name of the program object that is currently active, or 0 if no program object is active.
                        See "
                         (code "glUseProgram")
                         ". "))
            (entry (% (heading (code "GL_CURRENT_RASTER_COLOR")))
                   (para)
                   (para (var "params")
                         " returns four values:
                        the red, green, blue, and alpha color values of the current raster position.
                        Integer values,
                        if requested,
                        are linearly mapped from the internal floating-point representation such
                        that 1.0 returns the most positive representable integer value,
                        and "
                         (math "-1.0")
                         "
returns the most negative representable integer
                        value. The initial value is (1, 1, 1, 1).
                        See "
                         (code "glRasterPos")
                         ". "))
            (entry (% (heading (code "GL_CURRENT_RASTER_DISTANCE")))
                   (para)
                   (para (var "params")
                         " returns one value, the distance from the eye to the current
                        raster position. The initial value is 0.
                        See "
                         (code "glRasterPos")
                         ". "))
            (entry (% (heading (code "GL_CURRENT_RASTER_INDEX")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the color index of the current raster position. The initial value is 1.
                        See "
                         (code "glRasterPos")
                         ". "))
            (entry (% (heading (code "GL_CURRENT_RASTER_POSITION")))
                   (para)
                   (para (var "params")
                         " returns four values:
                        the "
                         (var "x")
                         ", "
                         (var "y")
                         ", "
                         (var "z")
                         ", and "
                         (var "w")
                         " components of the current
                        raster position. "
                         (var "x")
                         ", "
                         (var "y")
                         ", and "
                         (var "z")
                         " are in window coordinates,
                        and "
                         (var "w")
                         " is in clip coordinates. The initial value is (0, 0, 0, 1).
                        See "
                         (code "glRasterPos")
                         ". "))
            (entry (% (heading
                        (code "GL_CURRENT_RASTER_POSITION_VALID")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether the current
                        raster position is valid. The initial value is "
                         (code "GL_TRUE")
                         ".
                        See "
                         (code "glRasterPos")
                         ". "))
            (entry (% (heading
                        (code "GL_CURRENT_RASTER_SECONDARY_COLOR")))
                   (para)
                   (para (var "params")
                         " returns four values:
                        the red, green, blue, and alpha secondary color values of the current raster position.
                        Integer values,
                        if requested,
                        are linearly mapped from the internal floating-point representation such
                        that 1.0 returns the most positive representable integer value,
                        and "
                         (math "-1.0")
                         "
returns the most negative representable integer
                        value. The initial value is (1, 1, 1, 1).
                        See "
                         (code "glRasterPos")
                         ". "))
            (entry (% (heading
                        (code "GL_CURRENT_RASTER_TEXTURE_COORDS")))
                   (para)
                   (para (var "params")
                         " returns four values: the "
                         (var "s")
                         ", "
                         (var "t")
                         ", "
                         (var "r")
                         ", and "
                         (var "q")
                         "
texture coordinates of the current raster position. The initial value is (0, 0, 0, 1).
                        See "
                         (code "glRasterPos")
                         " and "
                         (code "glMultiTexCoord")
                         ". "))
            (entry (% (heading (code "GL_CURRENT_SECONDARY_COLOR")))
                   (para)
                   (para (var "params")
                         " returns four values: the red, green, blue, and alpha values of the
                        current secondary color.  Integer values, if requested, are linearly mapped
                        from the internal floating-point representation such that 1.0 returns the
                        most positive representable integer value, and "
                         (math "-1.0")
                         "
returns the most
                        negative representable integer value.  The initial value is (0, 0, 0, 0).
                        See "
                         (code "glSecondaryColor")
                         ". "))
            (entry (% (heading (code "GL_CURRENT_TEXTURE_COORDS")))
                   (para)
                   (para (var "params")
                         " returns four values:
                        the "
                         (var "s")
                         ", "
                         (var "t")
                         ", "
                         (var "r")
                         ", and "
                         (var "q")
                         " current texture
                        coordinates. The initial value is (0, 0, 0, 1).
                        See "
                         (code "glMultiTexCoord")
                         ". "))
            (entry (% (heading (code "GL_DEPTH_BIAS")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the depth bias factor used during pixel transfers. The initial value is 0.
                        See "
                         (code "glPixelTransfer")
                         ". "))
            (entry (% (heading (code "GL_DEPTH_BITS")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the number of bitplanes in the depth buffer. "))
            (entry (% (heading (code "GL_DEPTH_CLEAR_VALUE")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the value that is used to clear the depth buffer.
                        Integer values,
                        if requested,
                        are linearly mapped from the internal floating-point representation such
                        that 1.0 returns the most positive representable integer value,
                        and "
                         (math "-1.0")
                         "
returns the most negative representable integer
                        value. The initial value is 1.
                        See "
                         (code "glClearDepth")
                         ". "))
            (entry (% (heading (code "GL_DEPTH_FUNC")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the symbolic constant that indicates the depth comparison
                        function. The initial value is "
                         (code "GL_LESS")
                         ".
                        See "
                         (code "glDepthFunc")
                         ". "))
            (entry (% (heading (code "GL_DEPTH_RANGE")))
                   (para)
                   (para (var "params")
                         " returns two values:
                        the near and far mapping limits for the depth buffer.
                        Integer values,
                        if requested,
                        are linearly mapped from the internal floating-point representation such
                        that 1.0 returns the most positive representable integer value,
                        and "
                         (math "-1.0")
                         "
returns the most negative representable integer
                        value. The initial value is (0, 1).
                        See "
                         (code "glDepthRange")
                         ". "))
            (entry (% (heading (code "GL_DEPTH_SCALE")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the depth scale factor used during pixel transfers. The initial value is 1.
                        See "
                         (code "glPixelTransfer")
                         ". "))
            (entry (% (heading (code "GL_DEPTH_TEST")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether depth testing
                        of fragments is enabled. The initial value is "
                         (code "GL_FALSE")
                         ".
                        See "
                         (code "glDepthFunc")
                         " and "
                         (code "glDepthRange")
                         ". "))
            (entry (% (heading (code "GL_DEPTH_WRITEMASK")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating if the depth buffer
                        is enabled for writing. The initial value is "
                         (code "GL_TRUE")
                         ".
                        See "
                         (code "glDepthMask")
                         ". "))
            (entry (% (heading (code "GL_DITHER")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether dithering of
                        fragment colors and indices is enabled. The initial value is "
                         (code "GL_TRUE")
                         ". "))
            (entry (% (heading (code "GL_DOUBLEBUFFER")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether double buffering
                        is supported. "))
            (entry (% (heading (code "GL_DRAW_BUFFER")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        a symbolic constant indicating which buffers are being drawn to.
                        See "
                         (code "glDrawBuffer")
                         ". The initial value is "
                         (code "GL_BACK")
                         " if there
                        are back buffers, otherwise it is "
                         (code "GL_FRONT")
                         ". "))
            (entry (% (heading (code "GL_DRAW_BUFFER") (var "i")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        a symbolic constant indicating which buffers are being drawn to by the corresponding output color.
                        See "
                         (code "glDrawBuffers")
                         ". 
                        The initial value of "
                         (code "GL_DRAW_BUFFER0")
                         " is "
                         (code "GL_BACK")
                         " if there
                        are back buffers, otherwise it is "
                         (code "GL_FRONT")
                         ".  The
                        initial values of draw buffers for all other output colors is "
                         (code "GL_NONE")
                         ". "))
            (entry (% (heading (code "GL_EDGE_FLAG")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether the current
                        edge flag is "
                         (code "GL_TRUE")
                         " or "
                         (code "GL_FALSE")
                         ". The initial value is "
                         (code "GL_TRUE")
                         ".
                        See "
                         (code "glEdgeFlag")
                         ". "))
            (entry (% (heading (code "GL_EDGE_FLAG_ARRAY")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether the edge
                        flag array is enabled. The initial value is "
                         (code "GL_FALSE")
                         ".
                        See "
                         (code "glEdgeFlagPointer")
                         ". "))
            (entry (% (heading
                        (code "GL_EDGE_FLAG_ARRAY_BUFFER_BINDING")))
                   (para)
                   (para (var "params")
                         " returns a single value, the name of the buffer object
                        associated with the edge flag array. This buffer object would have been bound to the 
                        target "
                         (code "GL_ARRAY_BUFFER")
                         " at the time of the most recent call to "
                         (code "glEdgeFlagPointer")
                         ". 
                        If no buffer object was bound to this target, 0 is returned.  The initial value is 0.
                        See "
                         (code "glBindBuffer")
                         ". "))
            (entry (% (heading (code "GL_EDGE_FLAG_ARRAY_STRIDE")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the byte offset between consecutive edge flags in the edge flag
                        array. The initial value is 0.
                        See "
                         (code "glEdgeFlagPointer")
                         ". "))
            (entry (% (heading
                        (code "GL_ELEMENT_ARRAY_BUFFER_BINDING")))
                   (para)
                   (para (var "params")
                         " returns a single value, the name of the buffer object
                        currently bound to the target "
                         (code "GL_ELEMENT_ARRAY_BUFFER")
                         ". If no buffer object
                        is bound to this target, 0 is returned.  The initial value is 0.
                        See "
                         (code "glBindBuffer")
                         ". "))
            (entry (% (heading (code "GL_FEEDBACK_BUFFER_SIZE")))
                   (para)
                   (para (var "params")
                         " returns one value, the size of the feedback buffer.
                        See "
                         (code "glFeedbackBuffer")
                         ". "))
            (entry (% (heading (code "GL_FEEDBACK_BUFFER_TYPE")))
                   (para)
                   (para (var "params")
                         " returns one value, the type of the feedback buffer.
                        See "
                         (code "glFeedbackBuffer")
                         ". "))
            (entry (% (heading (code "GL_FOG")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether fogging is
                        enabled. The initial value is "
                         (code "GL_FALSE")
                         ".
                        See "
                         (code "glFog")
                         ". "))
            (entry (% (heading (code "GL_FOG_COORD_ARRAY")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether the fog coordinate array is enabled. The initial value is "
                         (code "GL_FALSE")
                         ".
                        See "
                         (code "glFogCoordPointer")
                         ". "))
            (entry (% (heading
                        (code "GL_FOG_COORD_ARRAY_BUFFER_BINDING")))
                   (para)
                   (para (var "params")
                         " returns a single value, the name of the buffer object
                        associated with the fog coordinate array. This buffer object would have been bound to the 
                        target "
                         (code "GL_ARRAY_BUFFER")
                         " at the time of the most recent call to "
                         (code "glFogCoordPointer")
                         ". 
                        If no buffer object was bound to this target, 0 is returned.  The initial value is 0.
                        See "
                         (code "glBindBuffer")
                         ". "))
            (entry (% (heading (code "GL_FOG_COORD_ARRAY_STRIDE")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the byte offset between consecutive fog coordinates in the fog coordinate
                        array. The initial value is 0.
                        See "
                         (code "glFogCoordPointer")
                         ". "))
            (entry (% (heading (code "GL_FOG_COORD_ARRAY_TYPE")))
                   (para)
                   (para (var "params")
                         " returns one value, the type of the fog coordinate array.
                        The initial value is "
                         (code "GL_FLOAT")
                         ".
                        See "
                         (code "glFogCoordPointer")
                         ". "))
            (entry (% (heading (code "GL_FOG_COORD_SRC")))
                   (para)
                   (para (var "params")
                         " returns one value, a symbolic constant indicating the source of the fog coordinate.
                        The initial value is "
                         (code "GL_FRAGMENT_DEPTH")
                         ".
                        See "
                         (code "glFog")
                         ". "))
            (entry (% (heading (code "GL_FOG_COLOR")))
                   (para)
                   (para (var "params")
                         " returns four values:
                        the red, green, blue, and alpha components of the fog color.
                        Integer values,
                        if requested,
                        are linearly mapped from the internal floating-point representation such
                        that 1.0 returns the most positive representable integer value,
                        and "
                         (math "-1.0")
                         "
returns the most negative representable integer
                        value. The initial value is (0, 0, 0, 0).
                        See "
                         (code "glFog")
                         ". "))
            (entry (% (heading (code "GL_FOG_DENSITY")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the fog density parameter. The initial value is 1.
                        See "
                         (code "glFog")
                         ". "))
            (entry (% (heading (code "GL_FOG_END")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the end factor for the linear fog equation. The initial value is 1.
                        See "
                         (code "glFog")
                         ". "))
            (entry (% (heading (code "GL_FOG_HINT")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        a symbolic constant indicating the mode of the fog hint. The initial value
                        is "
                         (code "GL_DONT_CARE")
                         ".
                        See "
                         (code "glHint")
                         ". "))
            (entry (% (heading (code "GL_FOG_INDEX")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the fog color index. The initial value is 0.
                        See "
                         (code "glFog")
                         ". "))
            (entry (% (heading (code "GL_FOG_MODE")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        a symbolic constant indicating which fog equation is selected. The initial
                        value is "
                         (code "GL_EXP")
                         ".
                        See "
                         (code "glFog")
                         ". "))
            (entry (% (heading (code "GL_FOG_START")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the start factor for the linear fog equation. The initial value is 0.
                        See "
                         (code "glFog")
                         ". "))
            (entry (% (heading
                        (code "GL_FRAGMENT_SHADER_DERIVATIVE_HINT")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        a symbolic constant indicating the mode of the derivative accuracy hint 
                        for fragment shaders. The initial value
                        is "
                         (code "GL_DONT_CARE")
                         ".
                        See "
                         (code "glHint")
                         ". "))
            (entry (% (heading (code "GL_FRONT_FACE")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        a symbolic constant indicating whether clockwise or counterclockwise
                        polygon winding is treated as front-facing. The initial value is "
                         (code "GL_CCW")
                         ".
                        See "
                         (code "glFrontFace")
                         ". "))
            (entry (% (heading (code "GL_GENERATE_MIPMAP_HINT")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        a symbolic constant indicating the mode of the mipmap generation filtering
                        hint. The initial value is "
                         (code "GL_DONT_CARE")
                         ".
                        See "
                         (code "glHint")
                         ". "))
            (entry (% (heading (code "GL_GREEN_BIAS")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the green bias factor used during pixel transfers. The initial value is 0. "))
            (entry (% (heading (code "GL_GREEN_BITS")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the number of green bitplanes in each color buffer. "))
            (entry (% (heading (code "GL_GREEN_SCALE")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the green scale factor used during pixel transfers. The initial value is 1.
                        See "
                         (code "glPixelTransfer")
                         ". "))
            (entry (% (heading (code "GL_HISTOGRAM")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether histogram is
                        enabled. The initial value is "
                         (code "GL_FALSE")
                         ".
                        See "
                         (code "glHistogram")
                         ". "))
            (entry (% (heading (code "GL_INDEX_ARRAY")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether the color
                        index array is enabled. The initial value is "
                         (code "GL_FALSE")
                         ".
                        See "
                         (code "glIndexPointer")
                         ". "))
            (entry (% (heading (code "GL_INDEX_ARRAY_BUFFER_BINDING")))
                   (para)
                   (para (var "params")
                         " returns a single value, the name of the buffer object
                        associated with the color index array. This buffer object would have been bound to the 
                        target "
                         (code "GL_ARRAY_BUFFER")
                         " at the time of the most recent call to "
                         (code "glIndexPointer")
                         ". 
                        If no buffer object was bound to this target, 0 is returned.  The initial value is 0.
                        See "
                         (code "glBindBuffer")
                         ". "))
            (entry (% (heading (code "GL_INDEX_ARRAY_STRIDE")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the byte offset between consecutive color indexes in the color index
                        array. The initial value is 0.
                        See "
                         (code "glIndexPointer")
                         ". "))
            (entry (% (heading (code "GL_INDEX_ARRAY_TYPE")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the data type of indexes in the color index array. The initial value is "
                         (code "GL_FLOAT")
                         ".
                        See "
                         (code "glIndexPointer")
                         ". "))
            (entry (% (heading (code "GL_INDEX_BITS")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the number of bitplanes in each color index buffer. "))
            (entry (% (heading (code "GL_INDEX_CLEAR_VALUE")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the color index used to clear the color index buffers. The initial value
                        is 0.
                        See "
                         (code "glClearIndex")
                         ". "))
            (entry (% (heading (code "GL_INDEX_LOGIC_OP")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether a fragment's index
                        values are merged into the framebuffer using a logical
                        operation. The initial value is "
                         (code "GL_FALSE")
                         ".
                        See "
                         (code "glLogicOp")
                         ". "))
            (entry (% (heading (code "GL_INDEX_MODE")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether the GL is in
                        color index mode ("
                         (code "GL_TRUE")
                         ") or RGBA mode ("
                         (code "GL_FALSE")
                         "). "))
            (entry (% (heading (code "GL_INDEX_OFFSET")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the offset added to color and stencil indices during pixel
                        transfers. The initial value is 0.
                        See "
                         (code "glPixelTransfer")
                         ". "))
            (entry (% (heading (code "GL_INDEX_SHIFT")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the amount that color and stencil indices are shifted during pixel
                        transfers. The initial value is 0.
                        See "
                         (code "glPixelTransfer")
                         ". "))
            (entry (% (heading (code "GL_INDEX_WRITEMASK")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        a mask indicating which bitplanes of each color index buffer can be
                        written. The initial value is all 1's.
                        See "
                         (code "glIndexMask")
                         ". "))
            (entry (% (heading (code "GL_LIGHT") (var "i")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether the specified
                        light is enabled. The initial value is "
                         (code "GL_FALSE")
                         ".
                        See "
                         (code "glLight")
                         " and "
                         (code "glLightModel")
                         ". "))
            (entry (% (heading (code "GL_LIGHTING")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether lighting is
                        enabled. The initial value is "
                         (code "GL_FALSE")
                         ".
                        See "
                         (code "glLightModel")
                         ". "))
            (entry (% (heading (code "GL_LIGHT_MODEL_AMBIENT")))
                   (para)
                   (para (var "params")
                         " returns four values:
                        the red, green, blue, and alpha components of the ambient intensity of
                        the entire scene.
                        Integer values,
                        if requested,
                        are linearly mapped from the internal floating-point representation such
                        that 1.0 returns the most positive representable integer value,
                        and "
                         (math "-1.0")
                         "
returns the most negative representable integer
                        value. The initial value is (0.2, 0.2, 0.2, 1.0).
                        See "
                         (code "glLightModel")
                         ". "))
            (entry (% (heading (code "GL_LIGHT_MODEL_COLOR_CONTROL")))
                   (para)
                   (para (var "params")
                         " returns single enumerated value indicating whether specular
                        reflection calculations are separated from normal lighting computations.
                        The initial value is "
                         (code "GL_SINGLE_COLOR")
                         ". "))
            (entry (% (heading (code "GL_LIGHT_MODEL_LOCAL_VIEWER")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether specular reflection
                        calculations treat the viewer as being local to the scene. The initial
                        value is "
                         (code "GL_FALSE")
                         ".
                        See "
                         (code "glLightModel")
                         ". "))
            (entry (% (heading (code "GL_LIGHT_MODEL_TWO_SIDE")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether separate materials
                        are used to compute lighting for front- and back-facing
                        polygons. The initial value is "
                         (code "GL_FALSE")
                         ".
                        See "
                         (code "glLightModel")
                         ". "))
            (entry (% (heading (code "GL_LINE_SMOOTH")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether antialiasing of
                        lines is enabled. The initial value is "
                         (code "GL_FALSE")
                         ".
                        See "
                         (code "glLineWidth")
                         ". "))
            (entry (% (heading (code "GL_LINE_SMOOTH_HINT")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        a symbolic constant indicating the mode of the line antialiasing
                        hint. The initial value is "
                         (code "GL_DONT_CARE")
                         ".
                        See "
                         (code "glHint")
                         ". "))
            (entry (% (heading (code "GL_LINE_STIPPLE")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether stippling of lines
                        is enabled. The initial value is "
                         (code "GL_FALSE")
                         ".
                        See "
                         (code "glLineStipple")
                         ". "))
            (entry (% (heading (code "GL_LINE_STIPPLE_PATTERN")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the 16-bit line stipple pattern. The initial value is all 1's.
                        See "
                         (code "glLineStipple")
                         ". "))
            (entry (% (heading (code "GL_LINE_STIPPLE_REPEAT")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the line stipple repeat factor. The initial value is 1.
                        See "
                         (code "glLineStipple")
                         ". "))
            (entry (% (heading (code "GL_LINE_WIDTH")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the line width as specified with "
                         (code "glLineWidth")
                         ". The initial value is
                        1. "))
            (entry (% (heading (code "GL_LINE_WIDTH_GRANULARITY")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the width difference between adjacent supported widths for antialiased lines.
                        See "
                         (code "glLineWidth")
                         ". "))
            (entry (% (heading (code "GL_LINE_WIDTH_RANGE")))
                   (para)
                   (para (var "params")
                         " returns two values:
                        the smallest and largest supported widths for antialiased
                        lines.
                        See "
                         (code "glLineWidth")
                         ". "))
            (entry (% (heading (code "GL_LIST_BASE")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the base offset added to all names in arrays presented to "
                         (code "glCallLists")
                         ". The initial value is 0.
                        See "
                         (code "glListBase")
                         ". "))
            (entry (% (heading (code "GL_LIST_INDEX")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the name of the display list currently under construction.
                        0 is returned if no display list is currently under
                        construction. The initial value is 0.
                        See "
                         (code "glNewList")
                         ". "))
            (entry (% (heading (code "GL_LIST_MODE")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        a symbolic constant indicating the construction mode of the display list
                        currently under construction. The initial value is 0.
                        See "
                         (code "glNewList")
                         ". "))
            (entry (% (heading (code "GL_LOGIC_OP_MODE")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        a symbolic constant indicating the selected logic operation
                        mode. The initial value is "
                         (code "GL_COPY")
                         ".
                        See "
                         (code "glLogicOp")
                         ". "))
            (entry (% (heading (code "GL_MAP1_COLOR_4")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether
                        1D evaluation generates colors. The initial value is "
                         (code "GL_FALSE")
                         ".
                        See "
                         (code "glMap1")
                         ". "))
            (entry (% (heading (code "GL_MAP1_GRID_DOMAIN")))
                   (para)
                   (para (var "params")
                         " returns two values:
                        the endpoints of the 1D map's grid domain. The initial value is (0, 1).
                        See "
                         (code "glMapGrid")
                         ". "))
            (entry (% (heading (code "GL_MAP1_GRID_SEGMENTS")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the number of partitions in the 1D map's grid domain. The initial value
                        is 1.
                        See "
                         (code "glMapGrid")
                         ". "))
            (entry (% (heading (code "GL_MAP1_INDEX")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether
                        1D evaluation generates color indices. The initial value is "
                         (code "GL_FALSE")
                         ".
                        See "
                         (code "glMap1")
                         ". "))
            (entry (% (heading (code "GL_MAP1_NORMAL")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether
                        1D evaluation generates normals. The initial value is "
                         (code "GL_FALSE")
                         ".
                        See "
                         (code "glMap1")
                         ". "))
            (entry (% (heading (code "GL_MAP1_TEXTURE_COORD_1")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether
                        1D evaluation generates 1D texture coordinates. The initial value is "
                         (code "GL_FALSE")
                         ".
                        See "
                         (code "glMap1")
                         ". "))
            (entry (% (heading (code "GL_MAP1_TEXTURE_COORD_2")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether
                        1D evaluation generates 2D texture coordinates. The initial value is "
                         (code "GL_FALSE")
                         ".
                        See "
                         (code "glMap1")
                         ". "))
            (entry (% (heading (code "GL_MAP1_TEXTURE_COORD_3")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether
                        1D evaluation generates 3D texture coordinates. The initial value is "
                         (code "GL_FALSE")
                         ".
                        See "
                         (code "glMap1")
                         ". "))
            (entry (% (heading (code "GL_MAP1_TEXTURE_COORD_4")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether
                        1D evaluation generates 4D texture coordinates. The initial value is "
                         (code "GL_FALSE")
                         ".
                        See "
                         (code "glMap1")
                         ". "))
            (entry (% (heading (code "GL_MAP1_VERTEX_3")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether
                        1D evaluation generates 3D vertex coordinates. The initial value is "
                         (code "GL_FALSE")
                         ".
                        See "
                         (code "glMap1")
                         ". "))
            (entry (% (heading (code "GL_MAP1_VERTEX_4")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether
                        1D evaluation generates 4D vertex coordinates. The initial value is "
                         (code "GL_FALSE")
                         ".
                        See "
                         (code "glMap1")
                         ". "))
            (entry (% (heading (code "GL_MAP2_COLOR_4")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether
                        2D evaluation generates colors. The initial value is "
                         (code "GL_FALSE")
                         ".
                        See "
                         (code "glMap2")
                         ". "))
            (entry (% (heading (code "GL_MAP2_GRID_DOMAIN")))
                   (para)
                   (para (var "params")
                         " returns four values:
                        the endpoints of the 2D map's "
                         (math (var "i"))
                         "
and "
                         (math (var "j"))
                         "
grid domains. The initial value
                        is (0,1; 0,1).
                        See "
                         (code "glMapGrid")
                         ". "))
            (entry (% (heading (code "GL_MAP2_GRID_SEGMENTS")))
                   (para)
                   (para (var "params")
                         " returns two values:
                        the number of partitions in the 2D map's "
                         (math (var "i"))
                         "
and "
                         (math (var "j"))
                         "
grid
                        domains. The initial value is (1,1).
                        See "
                         (code "glMapGrid")
                         ". "))
            (entry (% (heading (code "GL_MAP2_INDEX")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether
                        2D evaluation generates color indices. The initial value is "
                         (code "GL_FALSE")
                         ".
                        See "
                         (code "glMap2")
                         ". "))
            (entry (% (heading (code "GL_MAP2_NORMAL")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether
                        2D evaluation generates normals. The initial value is "
                         (code "GL_FALSE")
                         ".
                        See "
                         (code "glMap2")
                         ". "))
            (entry (% (heading (code "GL_MAP2_TEXTURE_COORD_1")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether
                        2D evaluation generates 1D texture coordinates. The initial value is "
                         (code "GL_FALSE")
                         ".
                        See "
                         (code "glMap2")
                         ". "))
            (entry (% (heading (code "GL_MAP2_TEXTURE_COORD_2")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether
                        2D evaluation generates 2D texture coordinates. The initial value is "
                         (code "GL_FALSE")
                         ".
                        See "
                         (code "glMap2")
                         ". "))
            (entry (% (heading (code "GL_MAP2_TEXTURE_COORD_3")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether
                        2D evaluation generates 3D texture coordinates. The initial value is "
                         (code "GL_FALSE")
                         ".
                        See "
                         (code "glMap2")
                         ". "))
            (entry (% (heading (code "GL_MAP2_TEXTURE_COORD_4")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether
                        2D evaluation generates 4D texture coordinates. The initial value is "
                         (code "GL_FALSE")
                         ".
                        See "
                         (code "glMap2")
                         ". "))
            (entry (% (heading (code "GL_MAP2_VERTEX_3")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether
                        2D evaluation generates 3D vertex coordinates. The initial value is "
                         (code "GL_FALSE")
                         ".
                        See "
                         (code "glMap2")
                         ". "))
            (entry (% (heading (code "GL_MAP2_VERTEX_4")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether
                        2D evaluation generates 4D vertex coordinates. The initial value is "
                         (code "GL_FALSE")
                         ".
                        See "
                         (code "glMap2")
                         ". "))
            (entry (% (heading (code "GL_MAP_COLOR")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating if colors and
                        color indices are to be replaced by table lookup during pixel
                        transfers. The initial value is "
                         (code "GL_FALSE")
                         ".
                        See "
                         (code "glPixelTransfer")
                         ". "))
            (entry (% (heading (code "GL_MAP_STENCIL")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating if stencil indices
                        are to be replaced by table lookup during pixel transfers. The initial
                        value is "
                         (code "GL_FALSE")
                         ".
                        See "
                         (code "glPixelTransfer")
                         ". "))
            (entry (% (heading (code "GL_MATRIX_MODE")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        a symbolic constant indicating which matrix stack is currently the
                        target of all matrix operations. The initial value is "
                         (code "GL_MODELVIEW")
                         ".
                        See "
                         (code "glMatrixMode")
                         ". "))
            (entry (% (heading (code "GL_MAX_3D_TEXTURE_SIZE")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        a rough estimate of the largest 3D texture that the GL can handle.
                        The value must be at least 16.
                        If the GL version is 1.2 or greater, use "
                         (code "GL_PROXY_TEXTURE_3D")
                         " to determine if a texture is too large.
                        See "
                         (code "glTexImage3D")
                         ". "))
            (entry (% (heading
                        (code "GL_MAX_CLIENT_ATTRIB_STACK_DEPTH")))
                   (para)
                   (para (var "params")
                         " returns one value indicating the maximum supported depth
                        of the client attribute stack.
                        See "
                         (code "glPushClientAttrib")
                         ". "))
            (entry (% (heading (code "GL_MAX_ATTRIB_STACK_DEPTH")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the maximum supported depth of the attribute stack. The value must be
                        at least 16.
                        See "
                         (code "glPushAttrib")
                         ". "))
            (entry (% (heading (code "GL_MAX_CLIP_PLANES")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the maximum number of application-defined clipping planes. The value must be at least 6.
                        See "
                         (code "glClipPlane")
                         ". "))
            (entry (% (heading
                        (code "GL_MAX_COLOR_MATRIX_STACK_DEPTH")))
                   (para)
                   (para (var "params")
                         " returns one value, the maximum supported depth of the color matrix
                        stack.  The value must be at least 2.
                        See "
                         (code "glPushMatrix")
                         ". "))
            (entry (% (heading
                        (code "GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS")))
                   (para)
                   (para (var "params")
                         " returns one value, the maximum supported texture image units that 
                        can be used to access texture maps from the vertex shader and the fragment processor combined. 
                        If both the vertex shader and the fragment processing stage access the same texture image
                        unit, then that counts as using two texture image units against this limit.
                        The value must be at least 2.
                        See "
                         (code "glActiveTexture")
                         ". "))
            (entry (% (heading (code "GL_MAX_CUBE_MAP_TEXTURE_SIZE")))
                   (para)
                   (para (var "params")
                         " returns one value.
                        The value gives a rough estimate of the largest cube-map texture that
                        the GL can handle. The value must be at least 16.
                        If the GL version is 1.3 or greater, use "
                         (code "GL_PROXY_TEXTURE_CUBE_MAP")
                         "
to determine if a texture is too large.
                        See "
                         (code "glTexImage2D")
                         ". "))
            (entry (% (heading (code "GL_MAX_DRAW_BUFFERS")))
                   (para)
                   (para (var "params")
                         " returns one value, the maximum number
                        of simultaneous output colors allowed from a fragment shader using the "
                         (code "gl_FragData")
                         " built-in array.  The value must be at least 1.
                        See "
                         (code "glDrawBuffers")
                         ". "))
            (entry (% (heading (code "GL_MAX_ELEMENTS_INDICES")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the recommended maximum number of vertex array indices.
                        See "
                         (code "glDrawRangeElements")
                         ". "))
            (entry (% (heading (code "GL_MAX_ELEMENTS_VERTICES")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the recommended maximum number of vertex array vertices.
                        See "
                         (code "glDrawRangeElements")
                         ". "))
            (entry (% (heading (code "GL_MAX_EVAL_ORDER")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the maximum equation order supported by 1D and 2D
                        evaluators. The value must be at least 8.
                        See "
                         (code "glMap1")
                         " and "
                         (code "glMap2")
                         ". "))
            (entry (% (heading
                        (code "GL_MAX_FRAGMENT_UNIFORM_COMPONENTS")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the maximum number of individual floating-point, integer, or boolean values that can be held 
                        in uniform variable storage for a fragment shader. The value must be at least 64.
                        See "
                         (code "glUniform")
                         ". "))
            (entry (% (heading (code "GL_MAX_LIGHTS")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the maximum number of lights. The value must be at least 8.
                        See "
                         (code "glLight")
                         ". "))
            (entry (% (heading (code "GL_MAX_LIST_NESTING")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the maximum recursion depth allowed during display-list
                        traversal. The value must be at least 64.
                        See "
                         (code "glCallList")
                         ". "))
            (entry (% (heading (code "GL_MAX_MODELVIEW_STACK_DEPTH")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the maximum supported depth of the modelview matrix stack. The value must
                        be at least 32.
                        See "
                         (code "glPushMatrix")
                         ". "))
            (entry (% (heading (code "GL_MAX_NAME_STACK_DEPTH")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the maximum supported depth of the selection name stack. The value must be at least 64.
                        See "
                         (code "glPushName")
                         ". "))
            (entry (% (heading (code "GL_MAX_PIXEL_MAP_TABLE")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the maximum supported size of a "
                         (code "glPixelMap")
                         " lookup table.
                        The value must be at least 32.
                        See "
                         (code "glPixelMap")
                         ". "))
            (entry (% (heading (code "GL_MAX_PROJECTION_STACK_DEPTH")))
                   (para)
                   (para (var "params")
                         " returns one value, the maximum supported depth of the projection
                        matrix stack. The value must be at least 2.
                        See "
                         (code "glPushMatrix")
                         ". "))
            (entry (% (heading (code "GL_MAX_TEXTURE_COORDS")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the maximum number of texture coordinate sets available to vertex and fragment shaders.
                        The value must be at least 2.
                        See "
                         (code "glActiveTexture")
                         " and "
                         (code "glClientActiveTexture")
                         ". "))
            (entry (% (heading (code "GL_MAX_TEXTURE_IMAGE_UNITS")))
                   (para)
                   (para (var "params")
                         " returns one value, the maximum supported texture image units that 
                        can be used to access texture maps from the fragment shader. 
                        The value must be at least 2.
                        See "
                         (code "glActiveTexture")
                         ". "))
            (entry (% (heading (code "GL_MAX_TEXTURE_LOD_BIAS")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the maximum, absolute value of the texture level-of-detail bias.  The
                        value must be at least 4. "))
            (entry (% (heading (code "GL_MAX_TEXTURE_SIZE")))
                   (para)
                   (para (var "params")
                         " returns one value.
                        The value gives a rough estimate of the largest texture that
                        the GL can handle. The value must be at least 64.
                        If the GL version is 1.1 or greater, use "
                         (code "GL_PROXY_TEXTURE_1D")
                         " or "
                         (code "GL_PROXY_TEXTURE_2D")
                         "
to determine if a texture is too large.
                        See "
                         (code "glTexImage1D")
                         " and "
                         (code "glTexImage2D")
                         ". "))
            (entry (% (heading (code "GL_MAX_TEXTURE_STACK_DEPTH")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the maximum supported depth of the texture matrix stack. The value must be at least 2.
                        See "
                         (code "glPushMatrix")
                         ". "))
            (entry (% (heading (code "GL_MAX_TEXTURE_UNITS")))
                   (para)
                   (para (var "params")
                         " returns a single value indicating the number of conventional 
                        texture units supported. Each conventional texture unit includes both a texture coordinate set
                        and a texture image unit.  Conventional texture units may be used for fixed-function (non-shader)
                        rendering.  The value must be at least 2.  Additional texture coordinate sets and texture
                        image units may be accessed from vertex and fragment shaders.
                        See "
                         (code "glActiveTexture")
                         " and "
                         (code "glClientActiveTexture")
                         ". "))
            (entry (% (heading (code "GL_MAX_VARYING_FLOATS")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the maximum number of interpolators available for processing varying variables used by
                        vertex and fragment shaders. This value represents the number of individual floating-point 
                        values that can be interpolated; varying variables declared as vectors, matrices, and arrays 
                        will all consume multiple interpolators. The value must be at least 32. "))
            (entry (% (heading (code "GL_MAX_VERTEX_ATTRIBS")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the maximum number of 4-component generic vertex attributes accessible to a vertex shader. 
                        The value must be at least 16.
                        See "
                         (code "glVertexAttrib")
                         ". "))
            (entry (% (heading
                        (code "GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS")))
                   (para)
                   (para (var "params")
                         " returns one value, the maximum supported texture image units that 
                        can be used to access texture maps from the vertex shader. The value may be 0.
                        See "
                         (code "glActiveTexture")
                         ". "))
            (entry (% (heading
                        (code "GL_MAX_VERTEX_UNIFORM_COMPONENTS")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the maximum number of individual floating-point, integer, or boolean values that can be held 
                        in uniform variable storage for a vertex shader. The value must be at least 512.
                        See "
                         (code "glUniform")
                         ". "))
            (entry (% (heading (code "GL_MAX_VIEWPORT_DIMS")))
                   (para)
                   (para (var "params")
                         " returns two values:
                        the maximum supported width and height of the viewport.
                        These must be at least as large as the visible dimensions of the display
                        being rendered to.
                        See "
                         (code "glViewport")
                         ". "))
            (entry (% (heading (code "GL_MINMAX")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether pixel minmax
                        values are computed.  The initial value is "
                         (code "GL_FALSE")
                         ".
                        See "
                         (code "glMinmax")
                         ". "))
            (entry (% (heading (code "GL_MODELVIEW_MATRIX")))
                   (para)
                   (para (var "params")
                         " returns sixteen values:
                        the modelview matrix on the top of the modelview matrix stack. Initially
                        this matrix is the identity matrix.
                        See "
                         (code "glPushMatrix")
                         ". "))
            (entry (% (heading (code "GL_MODELVIEW_STACK_DEPTH")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the number of matrices on the modelview matrix stack.
                        The initial value is 1.
                        See "
                         (code "glPushMatrix")
                         ". "))
            (entry (% (heading (code "GL_NAME_STACK_DEPTH")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the number of names on the selection name stack. The initial value is 0.
                        See "
                         (code "glPushName")
                         ". "))
            (entry (% (heading (code "GL_NORMAL_ARRAY")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value, indicating whether the normal
                        array is enabled. The initial value is "
                         (code "GL_FALSE")
                         ".
                        See "
                         (code "glNormalPointer")
                         ". "))
            (entry (% (heading (code "GL_NORMAL_ARRAY_BUFFER_BINDING")))
                   (para)
                   (para (var "params")
                         " returns a single value, the name of the buffer object
                        associated with the normal array. This buffer object would have been bound to the 
                        target "
                         (code "GL_ARRAY_BUFFER")
                         " at the time of the most recent call to "
                         (code "glNormalPointer")
                         ". 
                        If no buffer object was bound to this target, 0 is returned.  The initial value is 0.
                        See "
                         (code "glBindBuffer")
                         ". "))
            (entry (% (heading (code "GL_NORMAL_ARRAY_STRIDE")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the byte offset between consecutive normals in the normal
                        array. The initial value is 0.
                        See "
                         (code "glNormalPointer")
                         ". "))
            (entry (% (heading (code "GL_NORMAL_ARRAY_TYPE")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the data type of each coordinate in the normal array. The initial value is "
                         (code "GL_FLOAT")
                         ".
                        See "
                         (code "glNormalPointer")
                         ". "))
            (entry (% (heading (code "GL_NORMALIZE")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether normals are
                        automatically scaled to unit length after they have been transformed to
                        eye coordinates. The initial value is "
                         (code "GL_FALSE")
                         ".
                        See "
                         (code "glNormal")
                         ". "))
            (entry (% (heading
                        (code "GL_NUM_COMPRESSED_TEXTURE_FORMATS")))
                   (para)
                   (para (var "params")
                         " returns a single integer value indicating the number of available
                        compressed texture formats.  The minimum value is 0.
                        See "
                         (code "glCompressedTexImage2D")
                         ". "))
            (entry (% (heading (code "GL_PACK_ALIGNMENT")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the byte alignment used for writing pixel data to memory. The initial
                        value is 4.
                        See "
                         (code "glPixelStore")
                         ". "))
            (entry (% (heading (code "GL_PACK_IMAGE_HEIGHT")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the image height used for writing pixel data to memory.  The initial
                        value is 0.
                        See "
                         (code "glPixelStore")
                         ". "))
            (entry (% (heading (code "GL_PACK_LSB_FIRST")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether single-bit
                        pixels being written to memory are written first to the least significant
                        bit of each unsigned byte. The initial value is "
                         (code "GL_FALSE")
                         ".
                        See "
                         (code "glPixelStore")
                         ". "))
            (entry (% (heading (code "GL_PACK_ROW_LENGTH")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the row length used for writing pixel data to memory. The initial value is
                        0.
                        See "
                         (code "glPixelStore")
                         ". "))
            (entry (% (heading (code "GL_PACK_SKIP_IMAGES")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the number of pixel images skipped before the first pixel is written
                        into memory. The initial value is 0.
                        See "
                         (code "glPixelStore")
                         ". "))
            (entry (% (heading (code "GL_PACK_SKIP_PIXELS")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the number of pixel locations skipped before the first pixel is written
                        into memory. The initial value is 0.
                        See "
                         (code "glPixelStore")
                         ". "))
            (entry (% (heading (code "GL_PACK_SKIP_ROWS")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the number of rows of pixel locations skipped before the first pixel is written
                        into memory. The initial value is 0.
                        See "
                         (code "glPixelStore")
                         ". "))
            (entry (% (heading (code "GL_PACK_SWAP_BYTES")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether the bytes of
                        two-byte and four-byte pixel indices and components are swapped before being
                        written to memory. The initial value is "
                         (code "GL_FALSE")
                         ".
                        See "
                         (code "glPixelStore")
                         ". "))
            (entry (% (heading (code "GL_PERSPECTIVE_CORRECTION_HINT")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        a symbolic constant indicating the mode of the perspective correction
                        hint. The initial value is "
                         (code "GL_DONT_CARE")
                         ".
                        See "
                         (code "glHint")
                         ". "))
            (entry (% (heading (code "GL_PIXEL_MAP_A_TO_A_SIZE")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the size of the alpha-to-alpha pixel translation table.
                        The initial value is 1.
                        See "
                         (code "glPixelMap")
                         ". "))
            (entry (% (heading (code "GL_PIXEL_MAP_B_TO_B_SIZE")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the size of the blue-to-blue pixel translation table.
                        The initial value is 1.
                        See "
                         (code "glPixelMap")
                         ". "))
            (entry (% (heading (code "GL_PIXEL_MAP_G_TO_G_SIZE")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the size of the green-to-green pixel translation table.
                        The initial value is 1.
                        See "
                         (code "glPixelMap")
                         ". "))
            (entry (% (heading (code "GL_PIXEL_MAP_I_TO_A_SIZE")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the size of the index-to-alpha pixel translation table.
                        The initial value is 1.
                        See "
                         (code "glPixelMap")
                         ". "))
            (entry (% (heading (code "GL_PIXEL_MAP_I_TO_B_SIZE")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the size of the index-to-blue pixel translation table.
                        The initial value is 1.
                        See "
                         (code "glPixelMap")
                         ". "))
            (entry (% (heading (code "GL_PIXEL_MAP_I_TO_G_SIZE")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the size of the index-to-green pixel translation table.
                        The initial value is 1.
                        See "
                         (code "glPixelMap")
                         ". "))
            (entry (% (heading (code "GL_PIXEL_MAP_I_TO_I_SIZE")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the size of the index-to-index pixel translation table.
                        The initial value is 1.
                        See "
                         (code "glPixelMap")
                         ". "))
            (entry (% (heading (code "GL_PIXEL_MAP_I_TO_R_SIZE")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the size of the index-to-red pixel translation table.
                        The initial value is 1.
                        See "
                         (code "glPixelMap")
                         ". "))
            (entry (% (heading (code "GL_PIXEL_MAP_R_TO_R_SIZE")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the size of the red-to-red pixel translation table.
                        The initial value is 1.
                        See "
                         (code "glPixelMap")
                         ". "))
            (entry (% (heading (code "GL_PIXEL_MAP_S_TO_S_SIZE")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the size of the stencil-to-stencil pixel translation table.
                        The initial value is 1.
                        See "
                         (code "glPixelMap")
                         ". "))
            (entry (% (heading (code "GL_PIXEL_PACK_BUFFER_BINDING")))
                   (para)
                   (para (var "params")
                         " returns a single value, the name of the buffer object
                        currently bound to the target "
                         (code "GL_PIXEL_PACK_BUFFER")
                         ". If no buffer object
                        is bound to this target, 0 is returned.  The initial value is 0.
                        See "
                         (code "glBindBuffer")
                         ". "))
            (entry (% (heading (code "GL_PIXEL_UNPACK_BUFFER_BINDING")))
                   (para)
                   (para (var "params")
                         " returns a single value, the name of the buffer object
                        currently bound to the target "
                         (code "GL_PIXEL_UNPACK_BUFFER")
                         ". If no buffer object
                        is bound to this target, 0 is returned.  The initial value is 0.
                        See "
                         (code "glBindBuffer")
                         ". "))
            (entry (% (heading (code "GL_POINT_DISTANCE_ATTENUATION")))
                   (para)
                   (para (var "params")
                         " returns three values,
                        the coefficients for computing the attenuation value for points.
                        See "
                         (code "glPointParameter")
                         ". "))
            (entry (% (heading (code "GL_POINT_FADE_THRESHOLD_SIZE")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the point size threshold for determining the point size.
                        See "
                         (code "glPointParameter")
                         ". "))
            (entry (% (heading (code "GL_POINT_SIZE")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the point size as specified by "
                         (code "glPointSize")
                         ". The initial value is 1. "))
            (entry (% (heading (code "GL_POINT_SIZE_GRANULARITY")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the size difference between adjacent supported sizes for antialiased points.
                        See "
                         (code "glPointSize")
                         ". "))
            (entry (% (heading (code "GL_POINT_SIZE_MAX")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the upper bound for the attenuated point sizes.  The initial value is 0.0.
                        See "
                         (code "glPointParameter")
                         ". "))
            (entry (% (heading (code "GL_POINT_SIZE_MIN")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the lower bound for the attenuated point sizes. The initial value is 1.0.
                        See "
                         (code "glPointParameter")
                         ". "))
            (entry (% (heading (code "GL_POINT_SIZE_RANGE")))
                   (para)
                   (para (var "params")
                         " returns two values:
                        the smallest and largest supported sizes for antialiased
                        points. The smallest size must be at most 1, and the largest size must
                        be at least 1.
                        See "
                         (code "glPointSize")
                         ". "))
            (entry (% (heading (code "GL_POINT_SMOOTH")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether antialiasing of
                        points is enabled. The initial value is "
                         (code "GL_FALSE")
                         ".
                        See "
                         (code "glPointSize")
                         ". "))
            (entry (% (heading (code "GL_POINT_SMOOTH_HINT")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        a symbolic constant indicating the mode of the point antialiasing
                        hint. The initial value is "
                         (code "GL_DONT_CARE")
                         ".
                        See "
                         (code "glHint")
                         ". "))
            (entry (% (heading (code "GL_POINT_SPRITE")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether point sprite is
                        enabled. The initial value is "
                         (code "GL_FALSE")
                         ". "))
            (entry (% (heading (code "GL_POLYGON_MODE")))
                   (para)
                   (para (var "params")
                         " returns two values:
                        symbolic constants indicating whether front-facing and back-facing polygons
                        are rasterized as points, lines, or filled polygons. The initial value is "
                         (code "GL_FILL")
                         ".
                        See "
                         (code "glPolygonMode")
                         ". "))
            (entry (% (heading (code "GL_POLYGON_OFFSET_FACTOR")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the scaling factor used to determine the variable offset that is added
                        to the depth value of each fragment generated when a polygon is
                        rasterized. The initial value is 0.
                        See "
                         (code "glPolygonOffset")
                         ". "))
            (entry (% (heading (code "GL_POLYGON_OFFSET_UNITS")))
                   (para)
                   (para (var "params")
                         " returns one value.
                        This value is multiplied by an implementation-specific value and then
                        added to the depth value of each fragment
                        generated when a polygon is rasterized. The initial value is 0.
                        See "
                         (code "glPolygonOffset")
                         ". "))
            (entry (% (heading (code "GL_POLYGON_OFFSET_FILL")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether polygon offset
                        is enabled for polygons in fill mode. The initial value is "
                         (code "GL_FALSE")
                         ".
                        See "
                         (code "glPolygonOffset")
                         ". "))
            (entry (% (heading (code "GL_POLYGON_OFFSET_LINE")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether polygon offset
                        is enabled for polygons in line mode. The initial value is "
                         (code "GL_FALSE")
                         ".
                        See "
                         (code "glPolygonOffset")
                         ". "))
            (entry (% (heading (code "GL_POLYGON_OFFSET_POINT")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether polygon offset
                        is enabled for polygons in point mode. The initial value is "
                         (code "GL_FALSE")
                         ".
                        See "
                         (code "glPolygonOffset")
                         ". "))
            (entry (% (heading (code "GL_POLYGON_SMOOTH")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether antialiasing of
                        polygons is enabled. The initial value is "
                         (code "GL_FALSE")
                         ".
                        See "
                         (code "glPolygonMode")
                         ". "))
            (entry (% (heading (code "GL_POLYGON_SMOOTH_HINT")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        a symbolic constant indicating the mode of the polygon antialiasing
                        hint. The initial value is "
                         (code "GL_DONT_CARE")
                         ".
                        See "
                         (code "glHint")
                         ". "))
            (entry (% (heading (code "GL_POLYGON_STIPPLE")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether polygon
                        stippling is enabled. The initial value is "
                         (code "GL_FALSE")
                         ".
                        See "
                         (code "glPolygonStipple")
                         ". "))
            (entry (% (heading
                        (code "GL_POST_COLOR_MATRIX_COLOR_TABLE")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether post color
                        matrix transformation lookup is enabled.
                        The initial value is "
                         (code "GL_FALSE")
                         ".
                        See "
                         (code "glColorTable")
                         ". "))
            (entry (% (heading (code "GL_POST_COLOR_MATRIX_RED_BIAS")))
                   (para)
                   (para (var "params")
                         " returns one value, the red bias factor applied to RGBA fragments
                        after color matrix transformations.
                        The initial value is 0.
                        See "
                         (code "glPixelTransfer")
                         ". "))
            (entry (% (heading
                        (code "GL_POST_COLOR_MATRIX_GREEN_BIAS")))
                   (para)
                   (para (var "params")
                         " returns one value, the green bias factor applied to RGBA fragments
                        after color matrix transformations.
                        The initial value is 0.
                        See "
                         (code "glPixelTransfer")))
            (entry (% (heading (code "GL_POST_COLOR_MATRIX_BLUE_BIAS")))
                   (para)
                   (para (var "params")
                         " returns one value, the blue bias factor applied to RGBA fragments
                        after color matrix transformations.
                        The initial value is 0.
                        See "
                         (code "glPixelTransfer")
                         ". "))
            (entry (% (heading
                        (code "GL_POST_COLOR_MATRIX_ALPHA_BIAS")))
                   (para)
                   (para (var "params")
                         " returns one value, the alpha bias factor applied to RGBA fragments
                        after color matrix transformations.
                        The initial value is 0.
                        See "
                         (code "glPixelTransfer")
                         ". "))
            (entry (% (heading (code "GL_POST_COLOR_MATRIX_RED_SCALE")))
                   (para)
                   (para (var "params")
                         " returns one value, the red scale factor applied to RGBA fragments
                        after color matrix transformations.
                        The initial value is 1.
                        See "
                         (code "glPixelTransfer")
                         ". "))
            (entry (% (heading
                        (code "GL_POST_COLOR_MATRIX_GREEN_SCALE")))
                   (para)
                   (para (var "params")
                         " returns one value, the green scale factor applied to RGBA fragments
                        after color matrix transformations.
                        The initial value is 1.
                        See "
                         (code "glPixelTransfer")
                         ". "))
            (entry (% (heading
                        (code "GL_POST_COLOR_MATRIX_BLUE_SCALE")))
                   (para)
                   (para (var "params")
                         " returns one value, the blue scale factor applied to RGBA fragments
                        after color matrix transformations.
                        The initial value is 1.
                        See "
                         (code "glPixelTransfer")
                         ". "))
            (entry (% (heading
                        (code "GL_POST_COLOR_MATRIX_ALPHA_SCALE")))
                   (para)
                   (para (var "params")
                         " returns one value, the alpha scale factor applied to RGBA fragments
                        after color matrix transformations.
                        The initial value is 1.
                        See "
                         (code "glPixelTransfer")
                         ". "))
            (entry (% (heading
                        (code "GL_POST_CONVOLUTION_COLOR_TABLE")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether post convolution
                        lookup is enabled. The initial value is "
                         (code "GL_FALSE")
                         ".
                        See "
                         (code "glColorTable")
                         ". "))
            (entry (% (heading (code "GL_POST_CONVOLUTION_RED_BIAS")))
                   (para)
                   (para (var "params")
                         " returns one value, the red bias factor applied to RGBA fragments
                        after convolution. The initial value is 0.
                        See "
                         (code "glPixelTransfer")
                         ". "))
            (entry (% (heading (code "GL_POST_CONVOLUTION_GREEN_BIAS")))
                   (para)
                   (para (var "params")
                         " returns one value, the green bias factor applied to RGBA fragments
                        after convolution. The initial value is 0.
                        See "
                         (code "glPixelTransfer")
                         ". "))
            (entry (% (heading (code "GL_POST_CONVOLUTION_BLUE_BIAS")))
                   (para)
                   (para (var "params")
                         " returns one value, the blue bias factor applied to RGBA fragments
                        after convolution. The initial value is 0.
                        See "
                         (code "glPixelTransfer")
                         ". "))
            (entry (% (heading (code "GL_POST_CONVOLUTION_ALPHA_BIAS")))
                   (para)
                   (para (var "params")
                         " returns one value, the alpha bias factor applied to RGBA fragments
                        after convolution. The initial value is 0.
                        See "
                         (code "glPixelTransfer")
                         ". "))
            (entry (% (heading (code "GL_POST_CONVOLUTION_RED_SCALE")))
                   (para)
                   (para (var "params")
                         " returns one value, the red scale factor applied to RGBA fragments
                        after convolution. The initial value is 1.
                        See "
                         (code "glPixelTransfer")
                         ". "))
            (entry (% (heading
                        (code "GL_POST_CONVOLUTION_GREEN_SCALE")))
                   (para)
                   (para (var "params")
                         " returns one value, the green scale factor applied to RGBA fragments
                        after convolution. The initial value is 1.
                        See "
                         (code "glPixelTransfer")
                         ". "))
            (entry (% (heading (code "GL_POST_CONVOLUTION_BLUE_SCALE")))
                   (para)
                   (para (var "params")
                         " returns one value, the blue scale factor applied to RGBA fragments
                        after convolution. The initial value is 1.
                        See "
                         (code "glPixelTransfer")
                         ". "))
            (entry (% (heading
                        (code "GL_POST_CONVOLUTION_ALPHA_SCALE")))
                   (para)
                   (para (var "params")
                         " returns one value, the alpha scale factor applied to RGBA fragments
                        after convolution. The initial value is 1.
                        See "
                         (code "glPixelTransfer")
                         ". "))
            (entry (% (heading (code "GL_PROJECTION_MATRIX")))
                   (para)
                   (para (var "params")
                         " returns sixteen values:
                        the projection matrix on the top of the projection matrix
                        stack. Initially this matrix is the identity matrix.
                        See "
                         (code "glPushMatrix")
                         ". "))
            (entry (% (heading (code "GL_PROJECTION_STACK_DEPTH")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the number of matrices on the projection matrix stack.
                        The initial value is 1.
                        See "
                         (code "glPushMatrix")
                         ". "))
            (entry (% (heading (code "GL_READ_BUFFER")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        a symbolic constant indicating which color buffer is selected for
                        reading. The initial value is "
                         (code "GL_BACK")
                         " if there is a back buffer,
                        otherwise it is "
                         (code "GL_FRONT")
                         ".
                        See "
                         (code "glReadPixels")
                         " and "
                         (code "glAccum")
                         ". "))
            (entry (% (heading (code "GL_RED_BIAS")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the red bias factor used during pixel transfers. The initial value is 0. "))
            (entry (% (heading (code "GL_RED_BITS")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the number of red bitplanes in each color buffer. "))
            (entry (% (heading (code "GL_RED_SCALE")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the red scale factor used during pixel transfers. The initial value is 1.
                        See "
                         (code "glPixelTransfer")
                         ". "))
            (entry (% (heading (code "GL_RENDER_MODE")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        a symbolic constant indicating whether the GL is in render,
                        select,
                        or feedback mode. The initial value is "
                         (code "GL_RENDER")
                         ".
                        See "
                         (code "glRenderMode")
                         ". "))
            (entry (% (heading (code "GL_RESCALE_NORMAL")))
                   (para)
                   (para (var "params")
                         " returns single boolean value
                        indicating whether normal rescaling is enabled.
                        See "
                         (code "glEnable")
                         ". "))
            (entry (% (heading (code "GL_RGBA_MODE")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether the GL is in RGBA
                        mode (true) or color index mode (false).
                        See "
                         (code "glColor")
                         ". "))
            (entry (% (heading (code "GL_SAMPLE_BUFFERS")))
                   (para)
                   (para (var "params")
                         " returns a single integer value indicating the number of sample buffers
                        associated with the framebuffer.
                        See "
                         (code "glSampleCoverage")
                         ". "))
            (entry (% (heading (code "GL_SAMPLE_COVERAGE_VALUE")))
                   (para)
                   (para (var "params")
                         " returns a single positive floating-point value indicating the
                        current sample coverage value.
                        See "
                         (code "glSampleCoverage")
                         ". "))
            (entry (% (heading (code "GL_SAMPLE_COVERAGE_INVERT")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating if the temporary
                        coverage value should be inverted.
                        See "
                         (code "glSampleCoverage")
                         ". "))
            (entry (% (heading (code "GL_SAMPLES")))
                   (para)
                   (para (var "params")
                         " returns a single integer value indicating the coverage mask size.
                        See "
                         (code "glSampleCoverage")
                         ". "))
            (entry (% (heading (code "GL_SCISSOR_BOX")))
                   (para)
                   (para (var "params")
                         " returns four values:
                        the "
                         (math (var "x"))
                         "
and "
                         (math (var "y"))
                         "
window coordinates of the scissor box,
                        followed by its width and height.
                        Initially the "
                         (math (var "x"))
                         "
and "
                         (math (var "y"))
                         "
window coordinates are both 0 and the
                        width and height are set to the size of the window.
                        See "
                         (code "glScissor")
                         ". "))
            (entry (% (heading (code "GL_SCISSOR_TEST")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether scissoring is
                        enabled. The initial value is "
                         (code "GL_FALSE")
                         ".
                        See "
                         (code "glScissor")
                         ". "))
            (entry (% (heading (code "GL_SECONDARY_COLOR_ARRAY")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether the secondary color array is enabled. The initial value is "
                         (code "GL_FALSE")
                         ".
                        See "
                         (code "glSecondaryColorPointer")
                         ". "))
            (entry (% (heading
                        (code "GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING")))
                   (para)
                   (para (var "params")
                         " returns a single value, the name of the buffer object
                        associated with the secondary color array. This buffer object would have been bound to the 
                        target "
                         (code "GL_ARRAY_BUFFER")
                         " at the time of the most recent call to "
                         (code "glSecondaryColorPointer")
                         ". 
                        If no buffer object was bound to this target, 0 is returned.  The initial value is 0.
                        See "
                         (code "glBindBuffer")
                         ". "))
            (entry (% (heading (code "GL_SECONDARY_COLOR_ARRAY_SIZE")))
                   (para)
                   (para (var "params")
                         " returns one value, the number of components per color in the
                        secondary color array. The initial value is 3.
                        See "
                         (code "glSecondaryColorPointer")
                         ". "))
            (entry (% (heading
                        (code "GL_SECONDARY_COLOR_ARRAY_STRIDE")))
                   (para)
                   (para (var "params")
                         " returns one value, the byte offset between consecutive colors in
                        the secondary color array.  The initial value is 0.
                        See "
                         (code "glSecondaryColorPointer")
                         ". "))
            (entry (% (heading (code "GL_SECONDARY_COLOR_ARRAY_TYPE")))
                   (para)
                   (para (var "params")
                         " returns one value, the data type of each component in the secondary
                        color array. The initial value is "
                         (code "GL_FLOAT")
                         ".
                        See "
                         (code "glSecondaryColorPointer")
                         ". "))
            (entry (% (heading (code "GL_SELECTION_BUFFER_SIZE")))
                   (para)
                   (para (var "params")
                         " return one value,
                        the size of the selection buffer.
                        See "
                         (code "glSelectBuffer")
                         ". "))
            (entry (% (heading (code "GL_SEPARABLE_2D")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether 2D separable
                        convolution is enabled. The initial value is "
                         (code "GL_FALSE")
                         ".
                        See "
                         (code "glSeparableFilter2D")
                         ". "))
            (entry (% (heading (code "GL_SHADE_MODEL")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        a symbolic constant indicating whether the shading mode is flat or
                        smooth. The initial value is "
                         (code "GL_SMOOTH")
                         ".
                        See "
                         (code "glShadeModel")
                         ". "))
            (entry (% (heading (code "GL_SMOOTH_LINE_WIDTH_RANGE")))
                   (para)
                   (para (var "params")
                         " returns two values,
                        the smallest and largest supported widths for antialiased lines.
                        See "
                         (code "glLineWidth")
                         ". "))
            (entry (% (heading
                        (code "GL_SMOOTH_LINE_WIDTH_GRANULARITY")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the granularity of widths for antialiased lines.
                        See "
                         (code "glLineWidth")
                         ". "))
            (entry (% (heading (code "GL_SMOOTH_POINT_SIZE_RANGE")))
                   (para)
                   (para (var "params")
                         " returns two values,
                        the smallest and largest supported widths for antialiased points.
                        See "
                         (code "glPointSize")
                         ". "))
            (entry (% (heading
                        (code "GL_SMOOTH_POINT_SIZE_GRANULARITY")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the granularity of sizes for antialiased points.
                        See "
                         (code "glPointSize")
                         ". "))
            (entry (% (heading (code "GL_STENCIL_BACK_FAIL")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        a symbolic constant indicating what action is taken for back-facing polygons when the stencil
                        test fails. The initial value is "
                         (code "GL_KEEP")
                         ".
                        See "
                         (code "glStencilOpSeparate")
                         ". "))
            (entry (% (heading (code "GL_STENCIL_BACK_FUNC")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        a symbolic constant indicating what function is used for back-facing polygons to compare the
                        stencil reference value with the stencil buffer value. The initial value
                        is "
                         (code "GL_ALWAYS")
                         ".
                        See "
                         (code "glStencilFuncSeparate")
                         ". "))
            (entry (% (heading
                        (code "GL_STENCIL_BACK_PASS_DEPTH_FAIL")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        a symbolic constant indicating what action is taken for back-facing polygons when the stencil
                        test passes,
                        but the depth test fails. The initial value is "
                         (code "GL_KEEP")
                         ".
                        See "
                         (code "glStencilOpSeparate")
                         ". "))
            (entry (% (heading
                        (code "GL_STENCIL_BACK_PASS_DEPTH_PASS")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        a symbolic constant indicating what action is taken for back-facing polygons when the stencil
                        test passes and the depth test passes. The initial value is "
                         (code "GL_KEEP")
                         ".
                        See "
                         (code "glStencilOpSeparate")
                         ". "))
            (entry (% (heading (code "GL_STENCIL_BACK_REF")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the reference value that is compared with the contents of the stencil
                        buffer for back-facing polygons. The initial value is 0.
                        See "
                         (code "glStencilFuncSeparate")
                         ". "))
            (entry (% (heading (code "GL_STENCIL_BACK_VALUE_MASK")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the mask that is used for back-facing polygons to mask both the stencil reference value and the
                        stencil buffer value before they are compared. The initial value is all 1's.
                        See "
                         (code "glStencilFuncSeparate")
                         ". "))
            (entry (% (heading (code "GL_STENCIL_BACK_WRITEMASK")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the mask that controls writing of the stencil bitplanes for back-facing polygons. The initial value
                        is all 1's.
                        See "
                         (code "glStencilMaskSeparate")
                         ". "))
            (entry (% (heading (code "GL_STENCIL_BITS")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the number of bitplanes in the stencil buffer. "))
            (entry (% (heading (code "GL_STENCIL_CLEAR_VALUE")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the index to which the stencil bitplanes are cleared. The initial value is
                        0.
                        See "
                         (code "glClearStencil")
                         ". "))
            (entry (% (heading (code "GL_STENCIL_FAIL")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        a symbolic constant indicating what action is taken when the stencil
                        test fails. The initial value is "
                         (code "GL_KEEP")
                         ".
                        See "
                         (code "glStencilOp")
                         ".
                        If the GL version is 2.0 or greater, this stencil state only affects non-polygons
                        and front-facing polygons.  Back-facing polygons use separate stencil state.
                        See "
                         (code "glStencilOpSeparate")
                         ". "))
            (entry (% (heading (code "GL_STENCIL_FUNC")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        a symbolic constant indicating what function is used to compare the
                        stencil reference value with the stencil buffer value. The initial value
                        is "
                         (code "GL_ALWAYS")
                         ".
                        See "
                         (code "glStencilFunc")
                         ".
                        If the GL version is 2.0 or greater, this stencil state only affects non-polygons
                        and front-facing polygons.  Back-facing polygons use separate stencil state.
                        See "
                         (code "glStencilFuncSeparate")
                         ". "))
            (entry (% (heading (code "GL_STENCIL_PASS_DEPTH_FAIL")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        a symbolic constant indicating what action is taken when the stencil
                        test passes,
                        but the depth test fails. The initial value is "
                         (code "GL_KEEP")
                         ".
                        See "
                         (code "glStencilOp")
                         ".
                        If the GL version is 2.0 or greater, this stencil state only affects non-polygons
                        and front-facing polygons.  Back-facing polygons use separate stencil state.
                        See "
                         (code "glStencilOpSeparate")
                         ". "))
            (entry (% (heading (code "GL_STENCIL_PASS_DEPTH_PASS")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        a symbolic constant indicating what action is taken when the stencil
                        test passes and the depth test passes. The initial value is "
                         (code "GL_KEEP")
                         ".
                        See "
                         (code "glStencilOp")
                         ".
                        If the GL version is 2.0 or greater, this stencil state only affects non-polygons
                        and front-facing polygons.  Back-facing polygons use separate stencil state.
                        See "
                         (code "glStencilOpSeparate")
                         ". "))
            (entry (% (heading (code "GL_STENCIL_REF")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the reference value that is compared with the contents of the stencil
                        buffer. The initial value is 0.
                        See "
                         (code "glStencilFunc")
                         ".
                        If the GL version is 2.0 or greater, this stencil state only affects non-polygons
                        and front-facing polygons.  Back-facing polygons use separate stencil state.
                        See "
                         (code "glStencilFuncSeparate")
                         ". "))
            (entry (% (heading (code "GL_STENCIL_TEST")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether stencil testing
                        of fragments is enabled. The initial value is "
                         (code "GL_FALSE")
                         ".
                        See "
                         (code "glStencilFunc")
                         " and "
                         (code "glStencilOp")
                         ". "))
            (entry (% (heading (code "GL_STENCIL_VALUE_MASK")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the mask that is used to mask both the stencil reference value and the
                        stencil buffer value before they are compared. The initial value is all 1's.
                        See "
                         (code "glStencilFunc")
                         ".
                        If the GL version is 2.0 or greater, this stencil state only affects non-polygons
                        and front-facing polygons.  Back-facing polygons use separate stencil state.
                        See "
                         (code "glStencilFuncSeparate")
                         ". "))
            (entry (% (heading (code "GL_STENCIL_WRITEMASK")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the mask that controls writing of the stencil bitplanes. The initial value
                        is all 1's.
                        See "
                         (code "glStencilMask")
                         ".
                        If the GL version is 2.0 or greater, this stencil state only affects non-polygons
                        and front-facing polygons.  Back-facing polygons use separate stencil state.
                        See "
                         (code "glStencilMaskSeparate")
                         ". "))
            (entry (% (heading (code "GL_STEREO")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether stereo buffers
                        (left and right) are supported. "))
            (entry (% (heading (code "GL_SUBPIXEL_BITS")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        an estimate of the number of bits of subpixel resolution that are used to
                        position rasterized geometry in window coordinates. The value must be at least 4. "))
            (entry (% (heading (code "GL_TEXTURE_1D")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether 1D texture
                        mapping is enabled. The initial value is "
                         (code "GL_FALSE")
                         ".
                        See "
                         (code "glTexImage1D")
                         ". "))
            (entry (% (heading (code "GL_TEXTURE_BINDING_1D")))
                   (para)
                   (para (var "params")
                         " returns a single value, the name of the texture
                        currently bound to the target "
                         (code "GL_TEXTURE_1D")
                         ". The initial value is 0.
                        See "
                         (code "glBindTexture")
                         ". "))
            (entry (% (heading (code "GL_TEXTURE_2D")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether 2D texture
                        mapping is enabled. The initial value is "
                         (code "GL_FALSE")
                         ".
                        See "
                         (code "glTexImage2D")
                         ". "))
            (entry (% (heading (code "GL_TEXTURE_BINDING_2D")))
                   (para)
                   (para (var "params")
                         " returns a single value, the name of the texture
                        currently bound to the target "
                         (code "GL_TEXTURE_2D")
                         ". The initial value is 0.
                        See "
                         (code "glBindTexture")
                         ". "))
            (entry (% (heading (code "GL_TEXTURE_3D")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether 3D texture
                        mapping is enabled. The initial value is "
                         (code "GL_FALSE")
                         ".
                        See "
                         (code "glTexImage3D")
                         ". "))
            (entry (% (heading (code "GL_TEXTURE_BINDING_3D")))
                   (para)
                   (para (var "params")
                         " returns a single value, the name of the texture
                        currently bound to the target "
                         (code "GL_TEXTURE_3D")
                         ". The initial value is 0.
                        See "
                         (code "glBindTexture")
                         ". "))
            (entry (% (heading (code "GL_TEXTURE_BINDING_CUBE_MAP")))
                   (para)
                   (para (var "params")
                         " returns a single value, the name of the texture
                        currently bound to the target "
                         (code "GL_TEXTURE_CUBE_MAP")
                         ". The initial value is 0.
                        See "
                         (code "glBindTexture")
                         ". "))
            (entry (% (heading (code "GL_TEXTURE_COMPRESSION_HINT")))
                   (para)
                   (para (var "params")
                         " returns a single value indicating the mode of the texture
                        compression hint.  The initial value is "
                         (code "GL_DONT_CARE")
                         ". "))
            (entry (% (heading (code "GL_TEXTURE_COORD_ARRAY")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether the texture
                        coordinate array is enabled. The initial value is "
                         (code "GL_FALSE")
                         ".
                        See "
                         (code "glTexCoordPointer")
                         ". "))
            (entry (% (heading
                        (code "GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING")))
                   (para)
                   (para (var "params")
                         " returns a single value, the name of the buffer object
                        associated with the texture coordinate array. This buffer object would have been bound to the 
                        target "
                         (code "GL_ARRAY_BUFFER")
                         " at the time of the most recent call to "
                         (code "glTexCoordPointer")
                         ". 
                        If no buffer object was bound to this target, 0 is returned.  The initial value is 0.
                        See "
                         (code "glBindBuffer")
                         ". "))
            (entry (% (heading (code "GL_TEXTURE_COORD_ARRAY_SIZE")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the number of coordinates per element in the texture coordinate
                        array. The initial value is 4.
                        See "
                         (code "glTexCoordPointer")
                         ". "))
            (entry (% (heading (code "GL_TEXTURE_COORD_ARRAY_STRIDE")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the byte offset between consecutive elements in the texture coordinate
                        array. The initial value is 0.
                        See "
                         (code "glTexCoordPointer")
                         ". "))
            (entry (% (heading (code "GL_TEXTURE_COORD_ARRAY_TYPE")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the data type of the coordinates in the texture coordinate
                        array. The initial value is "
                         (code "GL_FLOAT")
                         ".
                        See "
                         (code "glTexCoordPointer")
                         ". "))
            (entry (% (heading (code "GL_TEXTURE_CUBE_MAP")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether cube-mapped texture
                        mapping is enabled.  The initial value is "
                         (code "GL_FALSE")
                         ".
                        See "
                         (code "glTexImage2D")
                         ". "))
            (entry (% (heading (code "GL_TEXTURE_GEN_Q")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether automatic generation
                        of the "
                         (var "q")
                         " texture coordinate is enabled. The initial value is "
                         (code "GL_FALSE")
                         ".
                        See "
                         (code "glTexGen")
                         ". "))
            (entry (% (heading (code "GL_TEXTURE_GEN_R")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether automatic generation
                        of the "
                         (var "r")
                         " texture coordinate is enabled. The initial value is "
                         (code "GL_FALSE")
                         ".
                        See "
                         (code "glTexGen")
                         ". "))
            (entry (% (heading (code "GL_TEXTURE_GEN_S")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether automatic generation
                        of the "
                         (var "S")
                         " texture coordinate is enabled. The initial value is "
                         (code "GL_FALSE")
                         ".
                        See "
                         (code "glTexGen")
                         ". "))
            (entry (% (heading (code "GL_TEXTURE_GEN_T")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether automatic generation
                        of the T texture coordinate is enabled. The initial value is "
                         (code "GL_FALSE")
                         ".
                        See "
                         (code "glTexGen")
                         ". "))
            (entry (% (heading (code "GL_TEXTURE_MATRIX")))
                   (para)
                   (para (var "params")
                         " returns sixteen values:
                        the texture matrix on the top of the texture matrix stack. Initially this
                        matrix is the identity matrix.
                        See "
                         (code "glPushMatrix")
                         ". "))
            (entry (% (heading (code "GL_TEXTURE_STACK_DEPTH")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the number of matrices on the texture matrix stack.
                        The initial value is 1.
                        See "
                         (code "glPushMatrix")
                         ". "))
            (entry (% (heading (code "GL_TRANSPOSE_COLOR_MATRIX")))
                   (para)
                   (para (var "params")
                         " returns 16 values, the elements of the color matrix in row-major
                        order.
                        See "
                         (code "glLoadTransposeMatrix")
                         ". "))
            (entry (% (heading (code "GL_TRANSPOSE_MODELVIEW_MATRIX")))
                   (para)
                   (para (var "params")
                         " returns 16 values, the elements of the modelview matrix in row-major
                        order.
                        See "
                         (code "glLoadTransposeMatrix")
                         ". "))
            (entry (% (heading (code "GL_TRANSPOSE_PROJECTION_MATRIX")))
                   (para)
                   (para (var "params")
                         " returns 16 values, the elements of the projection matrix in row-major
                        order.
                        See "
                         (code "glLoadTransposeMatrix")
                         ". "))
            (entry (% (heading (code "GL_TRANSPOSE_TEXTURE_MATRIX")))
                   (para)
                   (para (var "params")
                         " returns 16 values, the elements of the texture matrix in row-major
                        order.
                        See "
                         (code "glLoadTransposeMatrix")
                         ". "))
            (entry (% (heading (code "GL_UNPACK_ALIGNMENT")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the byte alignment used for reading pixel data from memory. The initial
                        value is 4.
                        See "
                         (code "glPixelStore")
                         ". "))
            (entry (% (heading (code "GL_UNPACK_IMAGE_HEIGHT")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the image height used for reading pixel data from memory.  The initial
                        is 0.
                        See "
                         (code "glPixelStore")
                         ". "))
            (entry (% (heading (code "GL_UNPACK_LSB_FIRST")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether single-bit
                        pixels being read from memory are read first from the least significant
                        bit of each unsigned byte. The initial value is "
                         (code "GL_FALSE")
                         ".
                        See "
                         (code "glPixelStore")
                         ". "))
            (entry (% (heading (code "GL_UNPACK_ROW_LENGTH")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the row length used for reading pixel data from memory. The initial value
                        is 0.
                        See "
                         (code "glPixelStore")
                         ". "))
            (entry (% (heading (code "GL_UNPACK_SKIP_IMAGES")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the number of pixel images skipped before the first pixel is read
                        from memory. The initial value is 0.
                        See "
                         (code "glPixelStore")
                         ". "))
            (entry (% (heading (code "GL_UNPACK_SKIP_PIXELS")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the number of pixel locations skipped before the first pixel is read
                        from memory. The initial value is 0.
                        See "
                         (code "glPixelStore")
                         ". "))
            (entry (% (heading (code "GL_UNPACK_SKIP_ROWS")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the number of rows of pixel locations skipped before the first pixel is read
                        from memory. The initial value is 0.
                        See "
                         (code "glPixelStore")
                         ". "))
            (entry (% (heading (code "GL_UNPACK_SWAP_BYTES")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether the bytes of
                        two-byte and four-byte pixel indices and components are swapped after being
                        read from memory. The initial value is "
                         (code "GL_FALSE")
                         ".
                        See "
                         (code "glPixelStore")
                         ". "))
            (entry (% (heading (code "GL_VERTEX_ARRAY")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether the vertex
                        array is enabled. The initial value is "
                         (code "GL_FALSE")
                         ".
                        See "
                         (code "glVertexPointer")
                         ". "))
            (entry (% (heading (code "GL_VERTEX_ARRAY_BUFFER_BINDING")))
                   (para)
                   (para (var "params")
                         " returns a single value, the name of the buffer object
                        associated with the vertex array. This buffer object would have been bound to the 
                        target "
                         (code "GL_ARRAY_BUFFER")
                         " at the time of the most recent call to "
                         (code "glVertexPointer")
                         ". 
                        If no buffer object was bound to this target, 0 is returned.  The initial value is 0.
                        See "
                         (code "glBindBuffer")
                         ". "))
            (entry (% (heading (code "GL_VERTEX_ARRAY_SIZE")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the number of coordinates per vertex in the vertex array. The initial
                        value is 4.
                        See "
                         (code "glVertexPointer")
                         ". "))
            (entry (% (heading (code "GL_VERTEX_ARRAY_STRIDE")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the byte offset between consecutive vertices in the vertex
                        array. The initial value is 0.
                        See "
                         (code "glVertexPointer")
                         ". "))
            (entry (% (heading (code "GL_VERTEX_ARRAY_TYPE")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the data type of each coordinate in the vertex array. The initial value is "
                         (code "GL_FLOAT")
                         ".
                        See "
                         (code "glVertexPointer")
                         ". "))
            (entry (% (heading (code "GL_VERTEX_PROGRAM_POINT_SIZE")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether vertex
                        program point size mode is enabled. If enabled, and a vertex shader is active, then the
                        point size is taken from the shader built-in "
                         (code "gl_PointSize")
                         ". If disabled,
                        and a vertex shader is active, then the point size is taken from the point state as specified
                        by "
                         (code "glPointSize")
                         ".
                        The initial value is "
                         (code "GL_FALSE")
                         ". "))
            (entry (% (heading (code "GL_VERTEX_PROGRAM_TWO_SIDE")))
                   (para)
                   (para (var "params")
                         " returns a single boolean value indicating whether vertex
                        program two-sided color mode is enabled. If enabled, and a vertex shader is active, then the
                        GL chooses the back color output for back-facing polygons, and the front color output for
                        non-polygons and front-facing polygons. If disabled, and a vertex shader is active, then the 
                        front color output is always selected. The initial value is "
                         (code "GL_FALSE")
                         ". "))
            (entry (% (heading (code "GL_VIEWPORT")))
                   (para)
                   (para (var "params")
                         " returns four values:
                        the "
                         (math (var "x"))
                         "
and "
                         (math (var "y"))
                         "
window coordinates of the viewport,
                        followed by its width and height.
                        Initially the "
                         (math (var "x"))
                         "
and "
                         (math (var "y"))
                         "
window coordinates are both set to 0,
                        and the width and height are set to the width and height of the window into
                        which the GL will do its rendering.
                        See "
                         (code "glViewport")
                         ". "))
            (entry (% (heading (code "GL_ZOOM_X")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the "
                         (math (var "x"))
                         "
pixel zoom factor. The initial value is 1.
                        See "
                         (code "glPixelZoom")
                         ". "))
            (entry (% (heading (code "GL_ZOOM_Y")))
                   (para)
                   (para (var "params")
                         " returns one value,
                        the "
                         (math (var "y"))
                         "
pixel zoom factor. The initial value is 1.
                        See "
                         (code "glPixelZoom")
                         ". ")))
     (para "
Many of the boolean parameters can also be queried more easily using "
           (code "glIsEnabled")
           ". ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "pname")
           " is not an accepted value. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glGet")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")
     (para)))

(define-gl-procedure
  glHint
  "glHint"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glHint"))
      (paramdef "GLenum " (parameter "target"))
      (paramdef "GLenum " (parameter "mode"))))
  '(*fragment*
     (heading "specify implementation-specific hints")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "target")))
                   (para "
Specifies a symbolic constant indicating the behavior to be controlled. "
                         (code "GL_FOG_HINT")
                         ", "
                         (code "GL_GENERATE_MIPMAP_HINT")
                         ", "
                         (code "GL_LINE_SMOOTH_HINT")
                         ", "
                         (code "GL_PERSPECTIVE_CORRECTION_HINT")
                         ", "
                         (code "GL_POINT_SMOOTH_HINT")
                         ", "
                         (code "GL_POLYGON_SMOOTH_HINT")
                         ", "
                         (code "GL_TEXTURE_COMPRESSION_HINT")
                         ", and "
                         (code "GL_FRAGMENT_SHADER_DERIVATIVE_HINT")
                         "
are accepted. "))
            (entry (% (heading (var "mode")))
                   (para "
Specifies a symbolic constant indicating the desired behavior. "
                         (code "GL_FASTEST")
                         ", "
                         (code "GL_NICEST")
                         ", and "
                         (code "GL_DONT_CARE")
                         " are accepted. ")))
     (heading "Description")
     (para "
Certain aspects of GL behavior,
            when there is room for interpretation,
            can be controlled with hints.
            A hint is specified with two arguments. "
           (var "target")
           " is a symbolic
            constant indicating the behavior to be controlled,
            and "
           (var "mode")
           " is another symbolic constant indicating the desired
            behavior. The initial value for each "
           (var "target")
           " is "
           (code "GL_DONT_CARE")
           ". "
           (var "mode")
           " can be one of the following: ")
     (table (% (formatter (asis)))
            (entry (% (heading (code "GL_FASTEST")))
                   (para)
                   (para "
The most efficient option should be chosen. "))
            (entry (% (heading (code "GL_NICEST")))
                   (para)
                   (para "
The most correct,
                        or highest quality,
                        option should be chosen. "))
            (entry (% (heading (code "GL_DONT_CARE")))
                   (para)
                   (para "
No preference. ")))
     (para "
Though the implementation aspects that can be hinted are well defined,
            the interpretation of the hints depends on the implementation.
            The hint aspects that can be specified with "
           (var "target")
           ",
            along with suggested semantics,
            are as follows: ")
     (table (% (formatter (asis)))
            (entry (% (heading (code "GL_FOG_HINT")))
                   (para)
                   (para "
Indicates the accuracy of fog calculation.
                        If per-pixel fog calculation is not efficiently supported
                        by the GL implementation,
                        hinting "
                         (code "GL_DONT_CARE")
                         " or "
                         (code "GL_FASTEST")
                         " can result in per-vertex
                        calculation of fog effects. "))
            (entry (% (heading
                        (code "GL_FRAGMENT_SHADER_DERIVATIVE_HINT")))
                   (para)
                   (para "
Indicates the accuracy of the derivative calculation for the GL shading language fragment processing built-in functions: "
                         (code "dFdx")
                         ", "
                         (code "dFdy")
                         ", and "
                         (code "fwidth")
                         ". "))
            (entry (% (heading (code "GL_GENERATE_MIPMAP_HINT")))
                   (para)
                   (para "
Indicates the quality of filtering when generating mipmap images. "))
            (entry (% (heading (code "GL_LINE_SMOOTH_HINT")))
                   (para)
                   (para "
Indicates the sampling quality of antialiased lines.
                        If a larger filter function is applied, hinting "
                         (code "GL_NICEST")
                         " can
                        result in more pixel fragments being generated during rasterization. "))
            (entry (% (heading (code "GL_PERSPECTIVE_CORRECTION_HINT")))
                   (para)
                   (para "
Indicates the quality of color, texture coordinate, and fog coordinate
                        interpolation.  If perspective-corrected parameter interpolation is not
                        efficiently supported by the GL implementation, hinting "
                         (code "GL_DONT_CARE")
                         "
or "
                         (code "GL_FASTEST")
                         " can result in simple linear interpolation of colors
                        and/or texture coordinates. "))
            (entry (% (heading (code "GL_POINT_SMOOTH_HINT")))
                   (para)
                   (para "
Indicates the sampling quality of antialiased points.
                        If a larger filter function is applied, hinting "
                         (code "GL_NICEST")
                         " can
                        result in more pixel fragments being generated during rasterization. "))
            (entry (% (heading (code "GL_POLYGON_SMOOTH_HINT")))
                   (para)
                   (para "
Indicates the sampling quality of antialiased polygons.
                        Hinting "
                         (code "GL_NICEST")
                         " can result in more pixel fragments being generated
                        during rasterization,
                        if a larger filter function is applied. "))
            (entry (% (heading (code "GL_TEXTURE_COMPRESSION_HINT")))
                   (para)
                   (para "
Indicates the quality and performance of the compressing texture images.
                        Hinting "
                         (code "GL_FASTEST")
                         " indicates that texture images should be compressed
                        as quickly as possible, while "
                         (code "GL_NICEST")
                         " indicates that texture images
                        should be compressed with as little image quality loss as possible. "
                         (code "GL_NICEST")
                         " should be selected if the texture is to be retrieved by "
                         (code "glGetCompressedTexImage")
                         " for reuse. ")))
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if either "
           (var "target")
           " or "
           (var "mode")
           " is not
            an accepted value. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glHint")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glHistogram
  "glHistogram"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glHistogram"))
      (paramdef "GLenum " (parameter "target"))
      (paramdef "GLsizei " (parameter "width"))
      (paramdef "GLenum " (parameter "internalformat"))
      (paramdef "GLboolean " (parameter "sink"))))
  '(*fragment*
     (heading "define histogram table")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "target")))
                   (para "
The histogram whose parameters are to be set.
                    Must be one of "
                         (code "GL_HISTOGRAM")
                         " or "
                         (code "GL_PROXY_HISTOGRAM")
                         ". "))
            (entry (% (heading (var "width")))
                   (para "
The number of entries in the histogram table.  Must be a power of 2. "))
            (entry (% (heading (var "internalformat")))
                   (para "
The format of entries in the histogram table.
                    Must be one of "
                         (code "GL_ALPHA")
                         ", "
                         (code "GL_ALPHA4")
                         ", "
                         (code "GL_ALPHA8")
                         ", "
                         (code "GL_ALPHA12")
                         ", "
                         (code "GL_ALPHA16")
                         ", "
                         (code "GL_LUMINANCE")
                         ", "
                         (code "GL_LUMINANCE4")
                         ", "
                         (code "GL_LUMINANCE8")
                         ", "
                         (code "GL_LUMINANCE12")
                         ", "
                         (code "GL_LUMINANCE16")
                         ", "
                         (code "GL_LUMINANCE_ALPHA")
                         ", "
                         (code "GL_LUMINANCE4_ALPHA4")
                         ", "
                         (code "GL_LUMINANCE6_ALPHA2")
                         ", "
                         (code "GL_LUMINANCE8_ALPHA8")
                         ", "
                         (code "GL_LUMINANCE12_ALPHA4")
                         ", "
                         (code "GL_LUMINANCE12_ALPHA12")
                         ", "
                         (code "GL_LUMINANCE16_ALPHA16")
                         ", "
                         (code "GL_R3_G3_B2")
                         ", "
                         (code "GL_RGB")
                         ", "
                         (code "GL_RGB4")
                         ", "
                         (code "GL_RGB5")
                         ", "
                         (code "GL_RGB8")
                         ", "
                         (code "GL_RGB10")
                         ", "
                         (code "GL_RGB12")
                         ", "
                         (code "GL_RGB16")
                         ", "
                         (code "GL_RGBA")
                         ", "
                         (code "GL_RGBA2")
                         ", "
                         (code "GL_RGBA4")
                         ", "
                         (code "GL_RGB5_A1")
                         ", "
                         (code "GL_RGBA8")
                         ", "
                         (code "GL_RGB10_A2")
                         ", "
                         (code "GL_RGBA12")
                         ", or "
                         (code "GL_RGBA16")
                         ". "))
            (entry (% (heading (var "sink")))
                   (para "
If "
                         (code "GL_TRUE")
                         ", pixels will be consumed by the histogramming
                    process and no drawing or texture loading will take place.
                    If "
                         (code "GL_FALSE")
                         ", pixels will proceed to the minmax process after
                    histogramming. ")))
     (heading "Description")
     (para "
When "
           (code "GL_HISTOGRAM")
           " is enabled, RGBA color components are converted to
            histogram table indices by clamping to the range [0,1], multiplying by
            the width of the histogram table, and rounding to the nearest integer.
            The table entries selected by the RGBA indices are then incremented.
            (If the internal format of the histogram table includes luminance, then
            the index derived from the R color component determines the luminance
            table entry to be incremented.)  If a histogram table entry is incremented
            beyond its maximum value, then its value becomes undefined.  (This is
            not an error.) ")
     (para "
Histogramming is performed only for RGBA pixels (though these may
            be specified originally as color indices and converted to RGBA by
            index table lookup).
            Histogramming is enabled with "
           (code "glEnable")
           " and disabled with "
           (code "glDisable")
           ". ")
     (para "
When "
           (var "target")
           " is "
           (code "GL_HISTOGRAM")
           ", "
           (code "glHistogram")
           " redefines the current
            histogram table to have "
           (var "width")
           " entries of the format specified by "
           (var "internalformat")
           ".
            The entries are indexed 0 through "
           (math (var "width") "-" "1")
           ",
            and
            all entries are initialized to zero.
            The values in the previous histogram table, if any, are lost.
            If "
           (var "sink")
           " is "
           (code "GL_TRUE")
           ", then pixels are discarded after histogramming;
            no further processing of the pixels takes place, and no drawing,
            texture loading, or pixel readback will result. ")
     (para "
When "
           (var "target")
           " is "
           (code "GL_PROXY_HISTOGRAM")
           ", "
           (code "glHistogram")
           " computes all
            state information as if the histogram table were to be redefined,
            but does not actually define the new table.
            If the requested histogram table is too large to be supported, then the
            state information will be set to zero.
            This provides a way to determine if a histogram table with the given
            parameters can be supported. ")
     (para)
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "target")
           " is not one of the allowable
            values. ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "width")
           " is less than zero or is
            not a power of 2. ")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "internalformat")
           " is not one of the
            allowable values. ")
     (para (code "GL_TABLE_TOO_LARGE")
           " is generated if "
           (var "target")
           " is "
           (code "GL_HISTOGRAM")
           "
and the histogram table specified is too large for the implementation. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glHistogram")
           " is executed
            between the execution of "
           (code "glBegin")
           " and the corresponding
            execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glIndexMask
  "glIndexMask"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glIndexMask"))
      (paramdef "GLuint " (parameter "mask"))))
  '(*fragment*
     (heading
       "control the writing of individual bits in the color index buffers")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "mask")))
                   (para "
Specifies a bit mask to enable and disable the writing of individual bits
                    in the color index buffers.
                    Initially, the mask is all 1's. ")))
     (heading "Description")
     (para (code "glIndexMask")
           " controls the writing of individual bits in the color index buffers.
            The least significant "
           (math (var "n"))
           "
bits of "
           (var "mask")
           ",
            where "
           (math (var "n"))
           "
is the number of bits in a color index buffer,
            specify a mask.
            Where a 1 (one) appears in the mask,
            it's possible to write to the corresponding bit in the color index
            buffer (or buffers).
            Where a 0 (zero) appears,
            the corresponding bit is write-protected. ")
     (para "
This mask is used only in color index mode,
            and it affects only the buffers currently selected for writing
            (see "
           (code "glDrawBuffer")
           ").
            Initially, all bits are enabled for writing. ")
     (heading "Errors")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glIndexMask")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glIndexPointer
  "glIndexPointer"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glIndexPointer"))
      (paramdef "GLenum " (parameter "type"))
      (paramdef "GLsizei " (parameter "stride"))
      (paramdef
        "const GLvoid * "
        (parameter "pointer"))))
  '(*fragment*
     (heading "define an array of color indexes")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "type")))
                   (para "
Specifies the data type of each color index in the array.
                    Symbolic constants "
                         (code "GL_UNSIGNED_BYTE")
                         ", "
                         (code "GL_SHORT")
                         ", "
                         (code "GL_INT")
                         ", "
                         (code "GL_FLOAT")
                         ",
                    and "
                         (code "GL_DOUBLE")
                         "
are accepted. The initial value is "
                         (code "GL_FLOAT")
                         ". "))
            (entry (% (heading (var "stride")))
                   (para "
Specifies the byte offset between consecutive color indexes.
                    If "
                         (var "stride")
                         " is 0, the color indexes are understood to
                    be tightly packed in the array. The initial value is 0. "))
            (entry (% (heading (var "pointer")))
                   (para "
Specifies a pointer to the first index in the array.
                    The initial value is 0. ")))
     (heading "Description")
     (para (code "glIndexPointer")
           " specifies the location and data format of an array of color indexes
            to use when rendering. "
           (var "type")
           " specifies the data type of
            each color index and "
           (var "stride")
           " specifies the byte stride from one
            color index to the next, allowing vertices and attributes
            to be packed into a single array or stored in separate arrays. ")
     (para "
If a non-zero named buffer object is bound to the "
           (code "GL_ARRAY_BUFFER")
           " target 
            (see "
           (code "glBindBuffer")
           ") while a color index array is
            specified, "
           (var "pointer")
           " is treated as a byte offset into the buffer object's data store.
            Also, the buffer object binding ("
           (code "GL_ARRAY_BUFFER_BINDING")
           ") is saved as color index vertex array
            client-side state ("
           (code "GL_INDEX_ARRAY_BUFFER_BINDING")
           "). ")
     (para "
When a color index array is specified, "
           (var "type")
           ", "
           (var "stride")
           ", and "
           (var "pointer")
           " are saved as client-side
            state, in addition to the current vertex array buffer object binding. ")
     (para "
To enable and disable the color index array, call "
           (code "glEnableClientState")
           " and "
           (code "glDisableClientState")
           " with the argument "
           (code "GL_INDEX_ARRAY")
           ". If
            enabled, the color index array is used
            when "
           (code "glDrawArrays")
           ", "
           (code "glMultiDrawArrays")
           ", "
           (code "glDrawElements")
           ", "
           (code "glMultiDrawElements")
           ", "
           (code "glDrawRangeElements")
           ", or "
           (code "glArrayElement")
           " is called. ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "type")
           " is not an accepted value. ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "stride")
           " is negative. ")))

(define-gl-procedure
  glIndex
  "glIndex"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glIndexs"))
      (paramdef "GLshort " (parameter "c"))))
  '(*fragment*
     (heading "set the current color index")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "c")))
                   (para "
Specifies the new value for the current color index. ")
                   (para)))
     (heading "Description")
     (para (code "glIndex")
           " updates the current (single-valued) color index.
            It takes one argument, the new value for the current color index. ")
     (para "
The current index is stored as a floating-point value.
            Integer values are converted directly to floating-point values,
            with no special mapping.
            The initial value is 1. ")
     (para "
Index values outside the representable range of the color index buffer
            are not clamped.
            However,
            before an index is dithered (if enabled) and written to the frame buffer,
            it is converted to fixed-point format.
            Any bits in the integer portion of the resulting fixed-point value
            that do not correspond to bits in the frame buffer are masked out. ")))

(define-gl-procedure
  glInitNames
  "glInitNames"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glInitNames"))
      (paramdef (parameter "void"))))
  '(*fragment*
     (heading "initialize the name stack")
     (heading "Description")
     (para "
The name stack is used during selection mode to allow sets of rendering
            commands to be uniquely identified.
            It consists of an ordered set of unsigned integers. "
           (code "glInitNames")
           " causes the name stack to be initialized to its default empty state. ")
     (para "
The name stack is always empty while the render mode is not "
           (code "GL_SELECT")
           ".
            Calls to "
           (code "glInitNames")
           " while the render mode is not "
           (code "GL_SELECT")
           " are ignored. ")
     (heading "Errors")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glInitNames")
           "
is executed between the execution of "
           (code "glBegin")
           " and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glInterleavedArrays
  "glInterleavedArrays"
  (funcsynopsis
    (funcprototype
      (funcdef
        "void "
        (function "glInterleavedArrays"))
      (paramdef "GLenum " (parameter "format"))
      (paramdef "GLsizei " (parameter "stride"))
      (paramdef
        "const GLvoid * "
        (parameter "pointer"))))
  '(*fragment*
     (heading
       "simultaneously specify and enable several interleaved arrays")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "format")))
                   (para "
Specifies the type of array to enable. Symbolic constants "
                         (code "GL_V2F")
                         ", "
                         (code "GL_V3F")
                         ", "
                         (code "GL_C4UB_V2F")
                         ", "
                         (code "GL_C4UB_V3F")
                         ", "
                         (code "GL_C3F_V3F")
                         ", "
                         (code "GL_N3F_V3F")
                         ", "
                         (code "GL_C4F_N3F_V3F")
                         ", "
                         (code "GL_T2F_V3F")
                         ", "
                         (code "GL_T4F_V4F")
                         ", "
                         (code "GL_T2F_C4UB_V3F")
                         ", "
                         (code "GL_T2F_C3F_V3F")
                         ", "
                         (code "GL_T2F_N3F_V3F")
                         ", "
                         (code "GL_T2F_C4F_N3F_V3F")
                         ",
                    and "
                         (code "GL_T4F_C4F_N3F_V4F")
                         "
are accepted. "))
            (entry (% (heading (var "stride")))
                   (para "
Specifies the offset in bytes between each aggregate array element. ")))
     (heading "Description")
     (para (code "glInterleavedArrays")
           " lets you specify and enable individual color,
            normal,
            texture and vertex
            arrays whose elements are part of a larger aggregate array element.
            For some implementations, this is more efficient than specifying the arrays
            separately. ")
     (para "
If "
           (var "stride")
           " is 0, the aggregate elements are stored consecutively.
            Otherwise, "
           (var "stride")
           " bytes occur between the beginning of one
            aggregate array element and the beginning of the next aggregate array
            element. ")
     (para (var "format")
           " serves as a ``key''
            describing the extraction of individual arrays from the aggregate array.
            If "
           (var "format")
           " contains a T, then texture coordinates are
            extracted from the interleaved array.  If C is present, color values
            are extracted. If N is present, normal coordinates are extracted.
            Vertex coordinates are always extracted. ")
     (para "
The digits 2, 3, and 4 denote how many values are extracted.
            F indicates that values are extracted as floating-point values.
            Colors may also be extracted as 4 unsigned bytes if 4UB follows the
            C.  If a color is extracted as 4 unsigned bytes, the vertex
            array element which follows is located at the first possible
            floating-point aligned address. ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "format")
           " is not an accepted value. ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "stride")
           " is negative. ")))

(define-gl-procedure
  glIsBuffer
  "glIsBuffer"
  (funcsynopsis
    (funcprototype
      (funcdef "GLboolean " (function "glIsBuffer"))
      (paramdef "GLuint " (parameter "buffer"))))
  '(*fragment*
     (heading
       "determine if a name corresponds to a buffer object")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "buffer")))
                   (para "
Specifies a value that may be the name of a buffer object. ")))
     (heading "Description")
     (para (code "glIsBuffer")
           " returns "
           (code "GL_TRUE")
           " if "
           (var "buffer")
           " is currently the name of a buffer object.
            If "
           (var "buffer")
           " is zero, or is a non-zero value that is not currently the
            name of a buffer object, or if an error occurs, "
           (code "glIsBuffer")
           " returns "
           (code "GL_FALSE")
           ". ")
     (para "
A name returned by "
           (code "glGenBuffers")
           ", but not yet associated with a buffer object
            by calling "
           (code "glBindBuffer")
           ", is not the name of a buffer object. ")
     (heading "Errors")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glIsBuffer")
           " is executed
            between the execution of "
           (code "glBegin")
           " and the corresponding
            execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glIsEnabled
  "glIsEnabled"
  (funcsynopsis
    (funcprototype
      (funcdef "GLboolean " (function "glIsEnabled"))
      (paramdef "GLenum " (parameter "cap"))))
  '(*fragment*
     (heading "test whether a capability is enabled")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "cap")))
                   (para "
Specifies a symbolic constant indicating a GL capability. ")))
     (heading "Description")
     (para (code "glIsEnabled")
           " returns "
           (code "GL_TRUE")
           " if "
           (var "cap")
           " is an enabled capability
            and returns "
           (code "GL_FALSE")
           " otherwise.
            Initially all capabilities except "
           (code "GL_DITHER")
           " are disabled; "
           (code "GL_DITHER")
           " is initially enabled. ")
     (para "
The following capabilities are accepted for "
           (var "cap")
           ": ")
     (para)
     (table (% (formatter (asis)))
            (entry (% (heading (strong "Constant")))
                   (para (strong "See")))
            (entry (% (heading (code "GL_ALPHA_TEST")))
                   (para (code "glAlphaFunc")))
            (entry (% (heading (code "GL_AUTO_NORMAL")))
                   (para (code "glEvalCoord")))
            (entry (% (heading (code "GL_BLEND")))
                   (para (code "glBlendFunc")
                         ", "
                         (code "glLogicOp")))
            (entry (% (heading (code "GL_CLIP_PLANE") (var "i")))
                   (para (code "glClipPlane")))
            (entry (% (heading (code "GL_COLOR_ARRAY")))
                   (para (code "glColorPointer")))
            (entry (% (heading (code "GL_COLOR_LOGIC_OP")))
                   (para (code "glLogicOp")))
            (entry (% (heading (code "GL_COLOR_MATERIAL")))
                   (para (code "glColorMaterial")))
            (entry (% (heading (code "GL_COLOR_SUM")))
                   (para (code "glSecondaryColor")))
            (entry (% (heading (code "GL_COLOR_TABLE")))
                   (para (code "glColorTable")))
            (entry (% (heading (code "GL_CONVOLUTION_1D")))
                   (para (code "glConvolutionFilter1D")))
            (entry (% (heading (code "GL_CONVOLUTION_2D")))
                   (para (code "glConvolutionFilter2D")))
            (entry (% (heading (code "GL_CULL_FACE")))
                   (para (code "glCullFace")))
            (entry (% (heading (code "GL_DEPTH_TEST")))
                   (para (code "glDepthFunc")
                         ", "
                         (code "glDepthRange")))
            (entry (% (heading (code "GL_DITHER")))
                   (para (code "glEnable")))
            (entry (% (heading (code "GL_EDGE_FLAG_ARRAY")))
                   (para (code "glEdgeFlagPointer")))
            (entry (% (heading (code "GL_FOG")))
                   (para (code "glFog")))
            (entry (% (heading (code "GL_FOG_COORD_ARRAY")))
                   (para (code "glFogCoordPointer")))
            (entry (% (heading (code "GL_HISTOGRAM")))
                   (para (code "glHistogram")))
            (entry (% (heading (code "GL_INDEX_ARRAY")))
                   (para (code "glIndexPointer")))
            (entry (% (heading (code "GL_INDEX_LOGIC_OP")))
                   (para (code "glLogicOp")))
            (entry (% (heading (code "GL_LIGHT") (var "i")))
                   (para (code "glLightModel")
                         ", "
                         (code "glLight")))
            (entry (% (heading (code "GL_LIGHTING")))
                   (para (code "glMaterial")
                         ", "
                         (code "glLightModel")
                         ", "
                         (code "glLight")))
            (entry (% (heading (code "GL_LINE_SMOOTH")))
                   (para (code "glLineWidth")))
            (entry (% (heading (code "GL_LINE_STIPPLE")))
                   (para (code "glLineStipple")))
            (entry (% (heading (code "GL_MAP1_COLOR_4")))
                   (para (code "glMap1")))
            (entry (% (heading (code "GL_MAP1_INDEX")))
                   (para (code "glMap1")))
            (entry (% (heading (code "GL_MAP1_NORMAL")))
                   (para (code "glMap1")))
            (entry (% (heading (code "GL_MAP1_TEXTURE_COORD_1")))
                   (para (code "glMap1")))
            (entry (% (heading (code "GL_MAP1_TEXTURE_COORD_2")))
                   (para (code "glMap1")))
            (entry (% (heading (code "GL_MAP1_TEXTURE_COORD_3")))
                   (para (code "glMap1")))
            (entry (% (heading (code "GL_MAP1_TEXTURE_COORD_4")))
                   (para (code "glMap1")))
            (entry (% (heading (code "GL_MAP2_COLOR_4")))
                   (para (code "glMap2")))
            (entry (% (heading (code "GL_MAP2_INDEX")))
                   (para (code "glMap2")))
            (entry (% (heading (code "GL_MAP2_NORMAL")))
                   (para (code "glMap2")))
            (entry (% (heading (code "GL_MAP2_TEXTURE_COORD_1")))
                   (para (code "glMap2")))
            (entry (% (heading (code "GL_MAP2_TEXTURE_COORD_2")))
                   (para (code "glMap2")))
            (entry (% (heading (code "GL_MAP2_TEXTURE_COORD_3")))
                   (para (code "glMap2")))
            (entry (% (heading (code "GL_MAP2_TEXTURE_COORD_4")))
                   (para (code "glMap2")))
            (entry (% (heading (code "GL_MAP2_VERTEX_3")))
                   (para (code "glMap2")))
            (entry (% (heading (code "GL_MAP2_VERTEX_4")))
                   (para (code "glMap2")))
            (entry (% (heading (code "GL_MINMAX")))
                   (para (code "glMinmax")))
            (entry (% (heading (code "GL_MULTISAMPLE")))
                   (para (code "glSampleCoverage")))
            (entry (% (heading (code "GL_NORMAL_ARRAY")))
                   (para (code "glNormalPointer")))
            (entry (% (heading (code "GL_NORMALIZE")))
                   (para (code "glNormal")))
            (entry (% (heading (code "GL_POINT_SMOOTH")))
                   (para (code "glPointSize")))
            (entry (% (heading (code "GL_POINT_SPRITE")))
                   (para (code "glEnable")))
            (entry (% (heading (code "GL_POLYGON_SMOOTH")))
                   (para (code "glPolygonMode")))
            (entry (% (heading (code "GL_POLYGON_OFFSET_FILL")))
                   (para (code "glPolygonOffset")))
            (entry (% (heading (code "GL_POLYGON_OFFSET_LINE")))
                   (para (code "glPolygonOffset")))
            (entry (% (heading (code "GL_POLYGON_OFFSET_POINT")))
                   (para (code "glPolygonOffset")))
            (entry (% (heading (code "GL_POLYGON_STIPPLE")))
                   (para (code "glPolygonStipple")))
            (entry (% (heading
                        (code "GL_POST_COLOR_MATRIX_COLOR_TABLE")))
                   (para (code "glColorTable")))
            (entry (% (heading
                        (code "GL_POST_CONVOLUTION_COLOR_TABLE")))
                   (para (code "glColorTable")))
            (entry (% (heading (code "GL_RESCALE_NORMAL")))
                   (para (code "glNormal")))
            (entry (% (heading (code "GL_SAMPLE_ALPHA_TO_COVERAGE")))
                   (para (code "glSampleCoverage")))
            (entry (% (heading (code "GL_SAMPLE_ALPHA_TO_ONE")))
                   (para (code "glSampleCoverage")))
            (entry (% (heading (code "GL_SAMPLE_COVERAGE")))
                   (para (code "glSampleCoverage")))
            (entry (% (heading (code "GL_SCISSOR_TEST")))
                   (para (code "glScissor")))
            (entry (% (heading (code "GL_SECONDARY_COLOR_ARRAY")))
                   (para (code "glSecondaryColorPointer")))
            (entry (% (heading (code "GL_SEPARABLE_2D")))
                   (para (code "glSeparableFilter2D")))
            (entry (% (heading (code "GL_STENCIL_TEST")))
                   (para (code "glStencilFunc")
                         ", "
                         (code "glStencilOp")))
            (entry (% (heading (code "GL_TEXTURE_1D")))
                   (para (code "glTexImage1D")))
            (entry (% (heading (code "GL_TEXTURE_2D")))
                   (para (code "glTexImage2D")))
            (entry (% (heading (code "GL_TEXTURE_3D")))
                   (para (code "glTexImage3D")))
            (entry (% (heading (code "GL_TEXTURE_COORD_ARRAY")))
                   (para (code "glTexCoordPointer")))
            (entry (% (heading (code "GL_TEXTURE_CUBE_MAP")))
                   (para (code "glTexImage2D")))
            (entry (% (heading (code "GL_TEXTURE_GEN_Q")))
                   (para (code "glTexGen")))
            (entry (% (heading (code "GL_TEXTURE_GEN_R")))
                   (para (code "glTexGen")))
            (entry (% (heading (code "GL_TEXTURE_GEN_S")))
                   (para (code "glTexGen")))
            (entry (% (heading (code "GL_TEXTURE_GEN_T")))
                   (para (code "glTexGen")))
            (entry (% (heading (code "GL_VERTEX_ARRAY")))
                   (para (code "glVertexPointer")))
            (entry (% (heading (code "GL_VERTEX_PROGRAM_POINT_SIZE")))
                   (para (code "glEnable")))
            (entry (% (heading (code "GL_VERTEX_PROGRAM_TWO_SIDE")))
                   (para (code "glEnable"))))
     (para)
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "cap")
           " is not an accepted value. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glIsEnabled")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glIsList
  "glIsList"
  (funcsynopsis
    (funcprototype
      (funcdef "GLboolean " (function "glIsList"))
      (paramdef "GLuint " (parameter "list"))))
  '(*fragment*
     (heading
       "determine if a name corresponds to a display list")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "list")))
                   (para "
Specifies a potential display list name. ")))
     (heading "Description")
     (para (code "glIsList")
           " returns "
           (code "GL_TRUE")
           " if "
           (var "list")
           " is the name
            of a display list and returns "
           (code "GL_FALSE")
           " if it is not, or if an error occurs. ")
     (para "
A name returned by "
           (code "glGenLists")
           ", but not yet associated with a display list
            by calling "
           (code "glNewList")
           ", is not the name of a display list. ")
     (heading "Errors")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glIsList")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glIsProgram
  "glIsProgram"
  (funcsynopsis
    (funcprototype
      (funcdef "GLboolean " (function "glIsProgram"))
      (paramdef "GLuint " (parameter "program"))))
  '(*fragment*
     (heading
       "Determines if a name corresponds to a program object")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "program")))
                   (para "Specifies a potential program object.")))
     (heading "Description")
     (para (code "glIsProgram")
           " returns\t"
           (code "GL_TRUE")
           " if "
           (var "program")
           "
is the name of a program object previously created with "
           (code "glCreateProgram")
           " and not yet deleted with "
           (code "glDeleteProgram")
           ".
\tIf "
           (var "program")
           " is zero or a non-zero value that
\tis not the name of a program object, or if an error occurs, "
           (code "glIsProgram")
           " returns "
           (code "GL_FALSE")
           ".")
     (heading "Errors")
     (para (code "GL_INVALID_OPERATION")
           " is generated if\t"
           (code "glIsProgram")
           " is executed between the
\texecution of\t"
           (code "glBegin")
           "
and the corresponding execution of\t"
           (code "glEnd")
           ".")))

(define-gl-procedure
  glIsQuery
  "glIsQuery"
  (funcsynopsis
    (funcprototype
      (funcdef "GLboolean " (function "glIsQuery"))
      (paramdef "GLuint " (parameter "id"))))
  '(*fragment*
     (heading
       "determine if a name corresponds to a query object")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "id")))
                   (para "
Specifies a value that may be the name of a query object. ")))
     (heading "Description")
     (para (code "glIsQuery")
           " returns "
           (code "GL_TRUE")
           " if "
           (var "id")
           " is currently the name of a query object.
            If "
           (var "id")
           " is zero, or is a non-zero value that is not currently the
            name of a query object, or if an error occurs, "
           (code "glIsQuery")
           " returns "
           (code "GL_FALSE")
           ". ")
     (para "
A name returned by "
           (code "glGenQueries")
           ", but not yet associated with a query object
            by calling "
           (code "glBeginQuery")
           ", is not the name of a query object. ")
     (heading "Errors")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glIsQuery")
           " is executed
            between the execution of "
           (code "glBegin")
           " and the corresponding
            execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glIsShader
  "glIsShader"
  (funcsynopsis
    (funcprototype
      (funcdef "GLboolean " (function "glIsShader"))
      (paramdef "GLuint " (parameter "shader"))))
  '(*fragment*
     (heading
       "Determines if a name corresponds to a shader object")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "shader")))
                   (para "Specifies a potential shader object.")))
     (heading "Description")
     (para (code "glIsShader")
           " returns\t"
           (code "GL_TRUE")
           " if "
           (var "shader")
           " is
\tthe name of a shader object previously created with "
           (code "glCreateShader")
           " and not yet deleted with "
           (code "glDeleteShader")
           ". 
        If "
           (var "shader")
           " is
\tzero or a non-zero value that is not the name of a shader
\tobject, or if an error occurs, "
           (code "glIsShader ")
           " returns\t"
           (code "GL_FALSE")
           ".")
     (heading "Errors")
     (para (code "GL_INVALID_OPERATION")
           " is generated if\t"
           (code "glIsShader")
           " is executed between the
\texecution of\t"
           (code "glBegin")
           "
and the corresponding execution of\t"
           (code "glEnd")
           ".")))

(define-gl-procedure
  glIsTexture
  "glIsTexture"
  (funcsynopsis
    (funcprototype
      (funcdef "GLboolean " (function "glIsTexture"))
      (paramdef "GLuint " (parameter "texture"))))
  '(*fragment*
     (heading
       "determine if a name corresponds to a texture")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "texture")))
                   (para "
Specifies a value that may be the name of a texture. ")))
     (heading "Description")
     (para (code "glIsTexture")
           " returns "
           (code "GL_TRUE")
           " if "
           (var "texture")
           " is currently the name of a texture.
            If "
           (var "texture")
           " is zero, or is a non-zero value that is not currently the
            name of a texture, or if an error occurs, "
           (code "glIsTexture")
           " returns "
           (code "GL_FALSE")
           ". ")
     (para "
A name returned by "
           (code "glGenTextures")
           ", but not yet associated with a texture
            by calling "
           (code "glBindTexture")
           ", is not the name of a texture. ")
     (heading "Errors")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glIsTexture")
           " is executed
            between the execution of "
           (code "glBegin")
           " and the corresponding
            execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glLightModel
  "glLightModel"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glLightModelf"))
      (paramdef "GLenum " (parameter "pname"))
      (paramdef "GLfloat " (parameter "param"))))
  '(*fragment*
     (heading "set the lighting model parameters")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "pname")))
                   (para "
Specifies a single-valued lighting model parameter. "
                         (code "GL_LIGHT_MODEL_LOCAL_VIEWER")
                         ", "
                         (code "GL_LIGHT_MODEL_COLOR_CONTROL")
                         ", and "
                         (code "GL_LIGHT_MODEL_TWO_SIDE")
                         " are accepted. "))
            (entry (% (heading (var "param")))
                   (para "
Specifies the value that "
                         (var "param")
                         " will be set to. ")))
     (heading "Description")
     (para (code "glLightModel")
           " sets the lighting model parameter. "
           (var "pname")
           " names a parameter and "
           (var "params")
           " gives the new value.
            There are three lighting model parameters: ")
     (table (% (formatter (asis)))
            (entry (% (heading (code "GL_LIGHT_MODEL_AMBIENT")))
                   (para)
                   (para (var "params")
                         " contains four integer or floating-point values that specify
                        the ambient RGBA intensity of the entire scene.
                        Integer values are mapped linearly such that the most positive representable
                        value maps to 1.0,
                        and the most negative representable value maps to "
                         (math "-1.0")
                         ".
                        Floating-point values are mapped directly.
                        Neither integer nor floating-point values are clamped.
                        The initial ambient scene intensity is (0.2, 0.2, 0.2, 1.0). "))
            (entry (% (heading (code "GL_LIGHT_MODEL_COLOR_CONTROL")))
                   (para)
                   (para (var "params")
                         " must be either "
                         (code "GL_SEPARATE_SPECULAR_COLOR")
                         " or "
                         (code "GL_SINGLE_COLOR")
                         ". "
                         (code "GL_SINGLE_COLOR")
                         " specifies that a single color is generated from the
                        lighting computation for a vertex. "
                         (code "GL_SEPARATE_SPECULAR_COLOR")
                         "
specifies that the specular color computation of lighting be stored
                        separately from the remainder of the lighting computation.  The specular
                        color is summed into the generated fragment's color after the application
                        of texture mapping (if enabled).  The initial value is "
                         (code "GL_SINGLE_COLOR")
                         ". "))
            (entry (% (heading (code "GL_LIGHT_MODEL_LOCAL_VIEWER")))
                   (para)
                   (para (var "params")
                         " is a single integer or floating-point value that specifies
                        how specular reflection angles are computed.
                        If "
                         (var "params")
                         " is 0 (or 0.0), specular reflection angles take the
                        view direction to be parallel to and in the direction of the -"
                         (var "z")
                         " axis,
                        regardless of the location of the vertex in eye coordinates.
                        Otherwise, specular reflections are computed from the origin
                        of the eye coordinate system.
                        The initial value is 0. "))
            (entry (% (heading (code "GL_LIGHT_MODEL_TWO_SIDE")))
                   (para)
                   (para (var "params")
                         " is a single integer or floating-point value that specifies
                        whether one- or two-sided lighting calculations are done for polygons.
                        It has no effect on the lighting calculations for points,
                        lines,
                        or bitmaps.
                        If "
                         (var "params")
                         " is 0 (or 0.0), one-sided lighting is specified,
                        and only the "
                         (var "front")
                         " material parameters are used in the
                        lighting equation.
                        Otherwise, two-sided lighting is specified.
                        In this case, vertices of back-facing polygons are lighted using the "
                         (var "back")
                         " material parameters
                        and have their normals reversed before the lighting equation is evaluated.
                        Vertices of front-facing polygons are always lighted using the "
                         (var "front")
                         " material parameters,
                        with no change to their normals. The initial value is 0. ")))
     (para "
In RGBA mode, the lighted color of a vertex is the sum of
            the material emission intensity,
            the product of the material ambient reflectance and the lighting model full-scene
            ambient intensity,
            and the contribution of each enabled light source.
            Each light source contributes the sum of three terms:
            ambient, diffuse, and specular.
            The ambient light source contribution is the product of the material ambient
            reflectance and the light's ambient intensity.
            The diffuse light source contribution is the product of the material diffuse
            reflectance,
            the light's diffuse intensity,
            and the dot product of the vertex's normal with the normalized vector from
            the vertex to the light source.
            The specular light source contribution is the product of the material specular
            reflectance,
            the light's specular intensity,
            and the dot product of the normalized vertex-to-eye and vertex-to-light
            vectors,
            raised to the power of the shininess of the material.
            All three light source contributions are attenuated equally based on
            the distance from the vertex to the light source and on light source
            direction, spread exponent, and spread cutoff angle.
            All dot products are replaced with 0 if they evaluate to a negative value. ")
     (para "
The alpha component of the resulting lighted color is set to the alpha value
            of the material diffuse reflectance. ")
     (para "
In color index mode,
            the value of the lighted index of a vertex ranges from the ambient
            to the specular values passed to "
           (code "glMaterial")
           " using "
           (code "GL_COLOR_INDEXES")
           ".
            Diffuse and specular coefficients,
            computed with a (.30, .59, .11) weighting of the lights' colors,
            the shininess of the material,
            and the same reflection and attenuation equations as in the RGBA case,
            determine how much above ambient the resulting index is. ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "pname")
           " is not an accepted value. ")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "pname")
           " is "
           (code "GL_LIGHT_MODEL_COLOR_CONTROL")
           " and "
           (var "params")
           " is not one of "
           (code "GL_SINGLE_COLOR")
           " or "
           (code "GL_SEPARATE_SPECULAR_COLOR")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glLightModel")
           " is executed between
            the execution of "
           (code "glBegin")
           " and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glLight
  "glLight"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glLightf"))
      (paramdef "GLenum " (parameter "light"))
      (paramdef "GLenum " (parameter "pname"))
      (paramdef "GLfloat " (parameter "param"))))
  '(*fragment*
     (heading "set light source parameters")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "light")))
                   (para "
Specifies a light.
                    The number of lights depends on the implementation,
                    but at least eight lights are supported.
                    They are identified by symbolic names of the form "
                         (code "GL_LIGHT")
                         (math (var "i"))
                         ",
                    where i ranges from 0 to the value of "
                         (code "GL_MAX_LIGHTS")
                         " - 1. "))
            (entry (% (heading (var "pname")))
                   (para "
Specifies a single-valued light source parameter for "
                         (var "light")
                         ". "
                         (code "GL_SPOT_EXPONENT")
                         ", "
                         (code "GL_SPOT_CUTOFF")
                         ", "
                         (code "GL_CONSTANT_ATTENUATION")
                         ", "
                         (code "GL_LINEAR_ATTENUATION")
                         ", and "
                         (code "GL_QUADRATIC_ATTENUATION")
                         " are accepted. "))
            (entry (% (heading (var "param")))
                   (para "
Specifies the value that parameter "
                         (var "pname")
                         " of light source "
                         (var "light")
                         "
will be set to. ")))
     (heading "Description")
     (para (code "glLight")
           " sets the values of individual light source parameters. "
           (var "light")
           " names the light and is a symbolic name of the form "
           (code "GL_LIGHT")
           (math (var "i"))
           ",
            where i ranges from 0 to the value of "
           (code "GL_MAX_LIGHTS")
           " - 1. "
           (var "pname")
           " specifies one of ten light source parameters,
            again by symbolic name. "
           (var "params")
           " is either a single value or a pointer to an array that contains
            the new values. ")
     (para "
To enable and disable lighting calculation, call "
           (code "glEnable")
           "
and "
           (code "glDisable")
           " with argument "
           (code "GL_LIGHTING")
           ". Lighting is
            initially disabled.
            When it is enabled,
            light sources that are enabled contribute to the lighting calculation.
            Light source "
           (math (var "i"))
           "
is enabled and disabled using "
           (code "glEnable")
           " and "
           (code "glDisable")
           " with argument "
           (code "GL_LIGHT")
           (math (var "i"))
           ". ")
     (para "
The ten light parameters are as follows: ")
     (table (% (formatter (asis)))
            (entry (% (heading (code "GL_AMBIENT")))
                   (para (var "params")
                         " contains four integer or floating-point values that specify
                        the ambient RGBA intensity of the light.
                        Integer values are mapped linearly such that the most positive representable
                        value maps to 1.0,
                        and the most negative representable value maps to "
                         (math "-1.0")
                         ".
                        Floating-point values are mapped directly.
                        Neither integer nor floating-point values are clamped.
                        The initial ambient light intensity is (0, 0, 0, 1). "))
            (entry (% (heading (code "GL_DIFFUSE")))
                   (para (var "params")
                         " contains four integer or floating-point values that specify
                        the diffuse RGBA intensity of the light.
                        Integer values are mapped linearly such that the most positive representable
                        value maps to 1.0,
                        and the most negative representable value maps to "
                         (math "-1.0")
                         ".
                        Floating-point values are mapped directly.
                        Neither integer nor floating-point values are clamped.
                        The initial value
                        for "
                         (code "GL_LIGHT0")
                         " is (1, 1, 1, 1); for other lights, the
                        initial value is (0, 0, 0, 1). "))
            (entry (% (heading (code "GL_SPECULAR")))
                   (para (var "params")
                         " contains four integer or floating-point values that specify
                        the specular RGBA intensity of the light.
                        Integer values are mapped linearly such that the most positive representable
                        value maps to 1.0,
                        and the most negative representable value maps to "
                         (math "-1.0")
                         ".
                        Floating-point values are mapped directly.
                        Neither integer nor floating-point values are clamped.
                        The initial value
                        for "
                         (code "GL_LIGHT0")
                         " is (1, 1, 1, 1); for other lights, the
                        initial value is (0, 0, 0, 1). "))
            (entry (% (heading (code "GL_POSITION")))
                   (para (var "params")
                         " contains four integer or floating-point values that specify
                        the position of the light in homogeneous object coordinates.
                        Both integer and floating-point values are mapped directly.
                        Neither integer nor floating-point values are clamped. ")
                   (para "
The position is transformed by the modelview matrix when "
                         (code "glLight")
                         " is called (just as if it were a point),
                        and it is stored in eye coordinates.
                        If the "
                         (math (var "w"))
                         "
component of the position is 0,
                        the light is treated as a directional source.
                        Diffuse and specular lighting calculations take the light's direction,
                        but not its actual position,
                        into account,
                        and attenuation is disabled.
                        Otherwise,
                        diffuse and specular lighting calculations are based on the actual location
                        of the light in eye coordinates,
                        and attenuation is enabled.
                        The initial position is (0, 0, 1, 0);
                        thus, the initial light source is directional,
                        parallel to, and in the direction of the "
                         (math "-" (var "z"))
                         "
axis. "))
            (entry (% (heading (code "GL_SPOT_DIRECTION")))
                   (para (var "params")
                         " contains three integer or floating-point values that specify
                        the direction of the light in homogeneous object coordinates.
                        Both integer and floating-point values are mapped directly.
                        Neither integer nor floating-point values are clamped. ")
                   (para "
The spot direction is transformed by the upper 3x3 of the modelview matrix when "
                         (code "glLight")
                         " is called,
                        and it is stored in eye coordinates.
                        It is significant only when "
                         (code "GL_SPOT_CUTOFF")
                         " is not 180,
                        which it is initially.
                        The initial direction is "
                         (math "(" "0" "," "0" "-1" ")")
                         ". "))
            (entry (% (heading (code "GL_SPOT_EXPONENT")))
                   (para (var "params")
                         " is a single integer or floating-point value that specifies
                        the intensity distribution of the light.
                        Integer and floating-point values are mapped directly.
                        Only values in the range "
                         (math "[" "0" "," "128" "]")
                         "
are accepted. ")
                   (para "
Effective light intensity is attenuated by the cosine of the angle between
                        the direction of the light and the direction from the light to the vertex
                        being lighted,
                        raised to the power of the spot exponent.
                        Thus, higher spot exponents result in a more focused light source,
                        regardless of the spot cutoff angle (see "
                         (code "GL_SPOT_CUTOFF")
                         ", next paragraph).
                        The initial spot exponent is 0,
                        resulting in uniform light distribution. "))
            (entry (% (heading (code "GL_SPOT_CUTOFF")))
                   (para (var "params")
                         " is a single integer or floating-point value that specifies
                        the maximum spread angle of a light source.
                        Integer and floating-point values are mapped directly.
                        Only values in the range "
                         (math "[" "0" "," "90" "]")
                         "
and the special value 180
                        are accepted.
                        If the angle between the direction of the light and the direction from the
                        light to the vertex being lighted is greater than the spot cutoff angle,
                        the light is completely masked.
                        Otherwise, its intensity is controlled by the spot exponent and the
                        attenuation factors.
                        The initial spot cutoff is 180,
                        resulting in uniform light distribution. "))
            (entry (% (heading (code "GL_CONSTANT_ATTENUATION"))))
            (entry (% (heading (code "GL_LINEAR_ATTENUATION"))))
            (entry (% (heading (code "GL_QUADRATIC_ATTENUATION")))
                   (para (var "params")
                         " is a single integer or floating-point value that specifies
                        one of the three light attenuation factors.
                        Integer and floating-point values are mapped directly.
                        Only nonnegative values are accepted.
                        If the light is positional,
                        rather than directional,
                        its intensity is attenuated by the reciprocal of the sum of the constant
                        factor, the linear factor times the distance between the light
                        and the vertex being lighted,
                        and the quadratic factor times the square of the same distance.
                        The initial attenuation factors are (1, 0, 0),
                        resulting in no attenuation. ")))
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if either "
           (var "light")
           " or "
           (var "pname")
           "
is not an accepted value. ")
     (para (code "GL_INVALID_VALUE")
           " is generated if a spot exponent value is specified
            outside the range "
           (math "[" "0" "," "128" "]")
           ",
            or if spot cutoff is specified outside the range "
           (math "[" "0" "," "90" "]")
           "
(except for the
            special value 180),
            or if a negative attenuation factor is specified. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glLight")
           " is executed between
            the execution of "
           (code "glBegin")
           " and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glLineStipple
  "glLineStipple"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glLineStipple"))
      (paramdef "GLint " (parameter "factor"))
      (paramdef "GLushort " (parameter "pattern"))))
  '(*fragment*
     (heading "specify the line stipple pattern")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "factor")))
                   (para "
Specifies a multiplier for each bit in the line stipple pattern.
                    If "
                         (var "factor")
                         " is 3,
                    for example,
                    each bit in the pattern is used three times
                    before the next bit in the pattern is used. "
                         (var "factor")
                         " is clamped to the range [1, 256] and defaults to 1. "))
            (entry (% (heading (var "pattern")))
                   (para "
Specifies a 16-bit integer whose bit pattern determines
                    which fragments of a line will be drawn when the line is rasterized.
                    Bit zero is used first; the default pattern is all 1's. ")))
     (heading "Description")
     (para "
Line stippling masks out certain fragments produced by rasterization;
            those fragments will not be drawn.
            The masking is achieved by using three parameters:
            the 16-bit line stipple pattern "
           (var "pattern")
           ",
            the repeat count "
           (var "factor")
           ",
            and an integer stipple counter "
           (math (var "s"))
           ". ")
     (para "
Counter "
           (math (var "s"))
           "
is reset to 0 whenever "
           (code "glBegin")
           " is called
            and before each line segment of a "
           (code "glBegin")
           "("
           (code "GL_LINES")
           ")/"
           (code "glEnd")
           "
sequence is generated.
            It is incremented after each fragment of a unit width aliased line segment
            is generated
            or after each "
           (math (var "i"))
           "
fragments of an "
           (math (var "i"))
           "
width line segment are generated.
            The "
           (math (var "i"))
           "
fragments associated with count "
           (math (var "s"))
           "
are masked out if ")
     (para (var "pattern")
           " bit "
           (math "("
                 (var "s")
                 "/"
                 (var "factor")
                 ","
                 ")"
                 "%"
                 "16"))
     (para "
is 0, otherwise these fragments are sent to the frame buffer.
            Bit zero of "
           (var "pattern")
           " is the least significant bit. ")
     (para "
Antialiased lines are treated as a sequence of "
           (math "1" "×" (var "width"))
           "
rectangles
            for purposes of stippling.
            Whether rectangle "
           (math (var "s"))
           "
is rasterized or not depends on the fragment rule
            described for aliased lines,
            counting rectangles rather than groups of fragments. ")
     (para "
To enable and disable line stippling, call "
           (code "glEnable")
           " and "
           (code "glDisable")
           "
with argument "
           (code "GL_LINE_STIPPLE")
           ".
            When enabled,
            the line stipple pattern is applied as described above.
            When disabled,
            it is as if the pattern were all 1's.
            Initially, line stippling is disabled. ")
     (heading "Errors")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glLineStipple")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glLineWidth
  "glLineWidth"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glLineWidth"))
      (paramdef "GLfloat " (parameter "width"))))
  '(*fragment*
     (heading "specify the width of rasterized lines")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "width")))
                   (para "
Specifies the width of rasterized lines.
                    The initial value is 1. ")))
     (heading "Description")
     (para (code "glLineWidth")
           " specifies the rasterized width of both aliased and antialiased
            lines.
            Using a line width other than 1 has different effects,
            depending on whether line antialiasing is enabled.
            To enable and disable line antialiasing, call "
           (code "glEnable")
           " and "
           (code "glDisable")
           "
with argument "
           (code "GL_LINE_SMOOTH")
           ". Line antialiasing is initially
            disabled. ")
     (para "
If line antialiasing is disabled,
            the actual width is determined by rounding the supplied width
            to the nearest integer.
            (If the rounding results in the value 0,
            it is as if the line width were 1.)
            If "
           (math "∣"
                 "Δ"
                 (var "x")
                 ","
                 "∣"
                 ">="
                 "∣"
                 "Δ"
                 (var "y")
                 ","
                 "∣")
           ", "
           (var "i")
           " pixels are filled in each column that is rasterized,
            where "
           (var "i")
           " is the rounded value of "
           (var "width")
           ".
            Otherwise, "
           (var "i")
           " pixels are filled in each row that is rasterized. ")
     (para "
If antialiasing is enabled,
            line rasterization produces a fragment for each pixel square
            that intersects the region lying within the rectangle having width
            equal to the current line width,
            length equal to the actual length of the line,
            and centered on the mathematical line segment.
            The coverage value for each fragment is the window coordinate area
            of the intersection of the rectangular region with the corresponding
            pixel square.
            This value is saved and used in the final rasterization step. ")
     (para "
Not all widths can be supported when line antialiasing is enabled. If an
            unsupported width is requested, the nearest supported width is used.
            Only width 1 is guaranteed to be supported; others depend on the
            implementation.  Likewise, there is a range for aliased line widths as well.
            To query the range of supported widths and the size
            difference between supported widths within the range, call "
           (code "glGet")
           "
with arguments "
           (code "GL_ALIASED_LINE_WIDTH_RANGE")
           ", "
           (code "GL_SMOOTH_LINE_WIDTH_RANGE")
           ", and "
           (code "GL_SMOOTH_LINE_WIDTH_GRANULARITY")
           ". ")
     (heading "Errors")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "width")
           " is less than or equal to 0. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glLineWidth")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glLinkProgram
  "glLinkProgram"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glLinkProgram"))
      (paramdef "GLuint " (parameter "program"))))
  '(*fragment*
     (heading "Links a program object")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "program")))
                   (para "Specifies the handle of the program object to be linked.")))
     (heading "Description")
     (para (code "glLinkProgram")
           " links the program
\tobject specified by "
           (var "program")
           ". If any
\tshader objects of type "
           (code "GL_VERTEX_SHADER")
           " are
\tattached to "
           (var "program")
           ", they will be used to
\tcreate an executable that will run on the programmable vertex
\tprocessor. If any shader objects of type\t"
           (code "GL_FRAGMENT_SHADER")
           " are attached to\t"
           (var "program")
           ", they will be used to create an
\texecutable that will run on the programmable fragment
\tprocessor.")
     (para "The status of the link operation will be stored as part of
\tthe program object's state. This value will be set to\t"
           (code "GL_TRUE")
           " if the program object was linked
\twithout errors and is ready for use, and\t"
           (code "GL_FALSE")
           " otherwise. It can be queried by
\tcalling\t"
           (code "glGetProgram")
           "
with arguments "
           (var "program")
           " and\t"
           (code "GL_LINK_STATUS")
           ".")
     (para "As a result of a successful link operation, all active
\tuser-defined uniform variables belonging to\t"
           (var "program")
           " will be initialized to 0, and
\teach of the program object's active uniform variables will be
\tassigned a location that can be queried by calling\t"
           (code "glGetUniformLocation")
           ".
\tAlso, any active user-defined attribute variables that have not
\tbeen bound to a generic vertex attribute index will be bound to
\tone at this time.")
     (para "Linking of a program object can fail for a number of
\treasons as specified in the "
           (var "OpenGL Shading Language
\tSpecification")
           ". The following lists some of the
\tconditions that will cause a link error.")
     (itemize
       (item (para "The number of active attribute variables supported
\t\tby the implementation has been exceeded."))
       (item (para "The storage limit for uniform variables has been
\t\texceeded."))
       (item (para "The number of active uniform variables supported
\t\tby the implementation has been exceeded."))
       (item (para "The "
                   (code "main")
                   " function is missing
\t\tfor the vertex shader or the fragment shader."))
       (item (para "A varying variable actually used in the fragment
\t\tshader is not declared in the same way (or is not
\t\tdeclared at all) in the vertex shader."))
       (item (para "A reference to a function or variable name is
\t\tunresolved."))
       (item (para "A shared global is declared with two different
\t\ttypes or two different initial values."))
       (item (para "One or more of the attached shader objects has not
\t\tbeen successfully compiled."))
       (item (para "Binding a generic attribute matrix caused some
\t\trows of the matrix to fall outside the allowed maximum
\t\tof "
                   (code "GL_MAX_VERTEX_ATTRIBS")
                   "."))
       (item (para "Not enough contiguous vertex attribute slots could
\t\tbe found to bind attribute matrices.")))
     (para "When a program object has been successfully linked, the
\tprogram object can be made part of current state by calling\t"
           (code "glUseProgram")
           ".
\tWhether or not the link operation was successful, the program
\tobject's information log will be overwritten. The information
\tlog can be retrieved by calling\t"
           (code "glGetProgramInfoLog")
           ".")
     (para (code "glLinkProgram")
           " will also install the
\tgenerated executables as part of the current rendering state if
\tthe link operation was successful and the specified program
\tobject is already currently in use as a result of a previous
\tcall to\t"
           (code "glUseProgram")
           ".
\tIf the program object currently in use is relinked
\tunsuccessfully, its link status will be set to\t"
           (code "GL_FALSE")
           " , but the executables and
\tassociated state will remain part of the current state until a
\tsubsequent call to "
           (code "glUseProgram")
           " removes it
\tfrom use. After it is removed from use, it cannot be made part
\tof current state until it has been successfully relinked.")
     (para "If "
           (var "program")
           " contains shader objects
\tof type "
           (code "GL_VERTEX_SHADER")
           " but does not
\tcontain shader objects of type\t"
           (code "GL_FRAGMENT_SHADER")
           ", the vertex shader will
\tbe linked against the implicit interface for fixed functionality
\tfragment processing. Similarly, if\t"
           (var "program")
           " contains shader objects of type\t"
           (code "GL_FRAGMENT_SHADER")
           " but it does not contain
\tshader objects of type "
           (code "GL_VERTEX_SHADER")
           ",
\tthe fragment shader will be linked against the implicit
\tinterface for fixed functionality vertex processing.")
     (para "The program object's information log is updated and the
\tprogram is generated at the time of the link operation. After
\tthe link operation, applications are free to modify attached
\tshader objects, compile attached shader objects, detach shader
\tobjects, delete shader objects, and attach additional shader
\tobjects. None of these operations affects the information log or
\tthe program that is part of the program object.")
     (heading "Errors")
     (para (code "GL_INVALID_VALUE")
           "
is generated if "
           (var "program")
           "
is not a value generated by OpenGL.")
     (para (code "GL_INVALID_OPERATION")
           "
is generated if "
           (var "program")
           "
is not a program object.")
     (para (code "GL_INVALID_OPERATION")
           "
is generated if "
           (code "glLinkProgram")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ".")))

(define-gl-procedure
  glListBase
  "glListBase"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glListBase"))
      (paramdef "GLuint " (parameter "base"))))
  '(*fragment*
     (heading "set the display-list base for ")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "base")))
                   (para "
Specifies an integer offset that will be added to "
                         (code "glCallLists")
                         "
offsets to generate display-list names.
                    The initial value is 0. ")))
     (heading "Description")
     (para (code "glCallLists")
           " specifies an array of offsets.
            Display-list names are generated by adding "
           (var "base")
           " to each offset.
            Names that reference valid display lists are executed;
            the others are ignored. ")
     (heading "Errors")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glListBase")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glLoadIdentity
  "glLoadIdentity"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glLoadIdentity"))
      (paramdef (parameter "void"))))
  '(*fragment*
     (heading
       "replace the current matrix with the identity matrix")
     (heading "Description")
     (para (code "glLoadIdentity")
           " replaces the current matrix with the identity matrix.
            It is semantically equivalent to calling "
           (code "glLoadMatrix")
           "
with the identity matrix ")
     (para)
     (para (math "("
                 "("
                 "1"
                 " "
                 "0"
                 " "
                 "0"
                 " "
                 "0"
                 ")"
                 ", "
                 "("
                 "0"
                 " "
                 "1"
                 " "
                 "0"
                 " "
                 "0"
                 ")"
                 ", "
                 "("
                 "0"
                 " "
                 "0"
                 " "
                 "1"
                 " "
                 "0"
                 ")"
                 ", "
                 "("
                 "0"
                 " "
                 "0"
                 " "
                 "0"
                 " "
                 "1"
                 ")"
                 ","
                 ","
                 ")"))
     (para)
     (para "
but in some cases it is more efficient. ")
     (heading "Errors")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glLoadIdentity")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glLoadMatrix
  "glLoadMatrix"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glLoadMatrixd"))
      (paramdef "const GLdouble * " (parameter "m"))))
  '(*fragment*
     (heading
       "replace the current matrix with the specified matrix")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "m")))
                   (para "
Specifies a pointer to 16 consecutive values, which are used as the
                    elements of a "
                         (math "4" "×" "4")
                         "
column-major matrix. ")))
     (heading "Description")
     (para (code "glLoadMatrix")
           " replaces the current matrix with the one whose elements are specified by "
           (var "m")
           ".
            The current matrix is the projection matrix,
            modelview matrix,
            or texture matrix,
            depending on the current matrix mode
            (see "
           (code "glMatrixMode")
           "). ")
     (para "
The current matrix, M, defines a transformation of coordinates.
            For instance, assume M refers to the modelview matrix.
            If "
           (math (var "v")
                 "="
                 "("
                 (var "v")
                 "\u2061"
                 "["
                 "0"
                 ","
                 "]"
                 ","
                 (var "v")
                 "\u2061"
                 "["
                 "1"
                 ","
                 "]"
                 (var "v")
                 "\u2061"
                 "["
                 "2"
                 ","
                 "]"
                 (var "v")
                 "\u2061"
                 "["
                 "3"
                 ","
                 "]"
                 ")")
           "
is the set of object coordinates
            of a vertex,
            and "
           (var "m")
           " points to an array of "
           (math "16")
           "
single- or double-precision
            floating-point values "
           (math (var "m")
                 "="
                 "{"
                 (var "m")
                 "\u2061"
                 "["
                 "0"
                 ","
                 "]"
                 ","
                 (var "m")
                 "\u2061"
                 "["
                 "1"
                 ","
                 "]"
                 (var "...")
                 (var "m")
                 "\u2061"
                 "["
                 "15"
                 ","
                 "]"
                 "}")
           ",
            then the modelview transformation "
           (math (var "M") "\u2061" "(" (var "v") "," ")")
           "
does the following: ")
     (para (math (var "M")
                 "\u2061"
                 "("
                 (var "v")
                 ","
                 ")"
                 "="
                 "("
                 "("
                 (var "m")
                 "\u2061"
                 "["
                 "0"
                 ","
                 "]"
                 " "
                 (var "m")
                 "\u2061"
                 "["
                 "4"
                 ","
                 "]"
                 " "
                 (var "m")
                 "\u2061"
                 "["
                 "8"
                 ","
                 "]"
                 " "
                 (var "m")
                 "\u2061"
                 "["
                 "12"
                 ","
                 "]"
                 ")"
                 ", "
                 "("
                 (var "m")
                 "\u2061"
                 "["
                 "1"
                 ","
                 "]"
                 " "
                 (var "m")
                 "\u2061"
                 "["
                 "5"
                 ","
                 "]"
                 " "
                 (var "m")
                 "\u2061"
                 "["
                 "9"
                 ","
                 "]"
                 " "
                 (var "m")
                 "\u2061"
                 "["
                 "13"
                 ","
                 "]"
                 ")"
                 ", "
                 "("
                 (var "m")
                 "\u2061"
                 "["
                 "2"
                 ","
                 "]"
                 " "
                 (var "m")
                 "\u2061"
                 "["
                 "6"
                 ","
                 "]"
                 " "
                 (var "m")
                 "\u2061"
                 "["
                 "10"
                 ","
                 "]"
                 " "
                 (var "m")
                 "\u2061"
                 "["
                 "14"
                 ","
                 "]"
                 ")"
                 ", "
                 "("
                 (var "m")
                 "\u2061"
                 "["
                 "3"
                 ","
                 "]"
                 " "
                 (var "m")
                 "\u2061"
                 "["
                 "7"
                 ","
                 "]"
                 " "
                 (var "m")
                 "\u2061"
                 "["
                 "11"
                 ","
                 "]"
                 " "
                 (var "m")
                 "\u2061"
                 "["
                 "15"
                 ","
                 "]"
                 ")"
                 ","
                 ")"
                 "×"
                 "("
                 "("
                 (var "v")
                 "\u2061"
                 "["
                 "0"
                 ","
                 "]"
                 ")"
                 ", "
                 "("
                 (var "v")
                 "\u2061"
                 "["
                 "1"
                 ","
                 "]"
                 ")"
                 ", "
                 "("
                 (var "v")
                 "\u2061"
                 "["
                 "2"
                 ","
                 "]"
                 ")"
                 ", "
                 "("
                 (var "v")
                 "\u2061"
                 "["
                 "3"
                 ","
                 "]"
                 ")"
                 ","
                 ")"))
     (para)
     (para "
Projection and texture transformations are similarly defined. ")
     (heading "Errors")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glLoadMatrix")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glLoadName
  "glLoadName"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glLoadName"))
      (paramdef "GLuint " (parameter "name"))))
  '(*fragment*
     (heading "load a name onto the name stack")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "name")))
                   (para "
Specifies a name that will replace the top value on the name stack. ")))
     (heading "Description")
     (para "
The name stack is used during selection mode to allow sets of rendering
            commands to be uniquely identified.
            It consists of an ordered set of unsigned integers and is initially empty. ")
     (para (code "glLoadName")
           " causes "
           (var "name")
           " to replace the value on the top of the name stack. ")
     (para "
The name stack is always empty while the render mode is not "
           (code "GL_SELECT")
           ".
            Calls to "
           (code "glLoadName")
           " while the render mode is not "
           (code "GL_SELECT")
           " are ignored. ")
     (heading "Errors")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glLoadName")
           " is called while the
            name stack is empty. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glLoadName")
           " is executed between
            the execution of "
           (code "glBegin")
           " and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glLoadTransposeMatrix
  "glLoadTransposeMatrix"
  (funcsynopsis
    (funcprototype
      (funcdef
        "void "
        (function "glLoadTransposeMatrixd"))
      (paramdef "const GLdouble * " (parameter "m"))))
  '(*fragment*
     (heading
       "replace the current matrix with the specified row-major ordered matrix")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "m")))
                   (para "
Specifies a pointer to 16 consecutive values, which are used as the
                    elements of a "
                         (math "4" "×" "4")
                         "
row-major matrix. ")))
     (heading "Description")
     (para (code "glLoadTransposeMatrix")
           " replaces the current matrix with the one whose elements are specified by "
           (var "m")
           ".
            The current matrix is the projection matrix,
            modelview matrix,
            or texture matrix,
            depending on the current matrix mode
            (see "
           (code "glMatrixMode")
           "). ")
     (para "
The current matrix, M, defines a transformation of coordinates.
            For instance, assume M refers to the modelview matrix.
            If "
           (math (var "v")
                 "="
                 "("
                 (var "v")
                 "\u2061"
                 "["
                 "0"
                 ","
                 "]"
                 ","
                 (var "v")
                 "\u2061"
                 "["
                 "1"
                 ","
                 "]"
                 (var "v")
                 "\u2061"
                 "["
                 "2"
                 ","
                 "]"
                 (var "v")
                 "\u2061"
                 "["
                 "3"
                 ","
                 "]"
                 ")")
           "
is the set of object coordinates
            of a vertex,
            and "
           (var "m")
           " points to an array of "
           (math "16")
           "
single- or double-precision
            floating-point values "
           (math (var "m")
                 "="
                 "{"
                 (var "m")
                 "\u2061"
                 "["
                 "0"
                 ","
                 "]"
                 ","
                 (var "m")
                 "\u2061"
                 "["
                 "1"
                 ","
                 "]"
                 (var "...")
                 (var "m")
                 "\u2061"
                 "["
                 "15"
                 ","
                 "]"
                 "}")
           ",
            then the modelview transformation "
           (math (var "M") "\u2061" "(" (var "v") "," ")")
           "
does the following: ")
     (para (math (var "M")
                 "\u2061"
                 "("
                 (var "v")
                 ","
                 ")"
                 "="
                 "("
                 "("
                 (var "m")
                 "\u2061"
                 "["
                 "0"
                 ","
                 "]"
                 " "
                 (var "m")
                 "\u2061"
                 "["
                 "1"
                 ","
                 "]"
                 " "
                 (var "m")
                 "\u2061"
                 "["
                 "2"
                 ","
                 "]"
                 " "
                 (var "m")
                 "\u2061"
                 "["
                 "3"
                 ","
                 "]"
                 ")"
                 ", "
                 "("
                 (var "m")
                 "\u2061"
                 "["
                 "4"
                 ","
                 "]"
                 " "
                 (var "m")
                 "\u2061"
                 "["
                 "5"
                 ","
                 "]"
                 " "
                 (var "m")
                 "\u2061"
                 "["
                 "6"
                 ","
                 "]"
                 " "
                 (var "m")
                 "\u2061"
                 "["
                 "7"
                 ","
                 "]"
                 ")"
                 ", "
                 "("
                 (var "m")
                 "\u2061"
                 "["
                 "8"
                 ","
                 "]"
                 " "
                 (var "m")
                 "\u2061"
                 "["
                 "9"
                 ","
                 "]"
                 " "
                 (var "m")
                 "\u2061"
                 "["
                 "10"
                 ","
                 "]"
                 " "
                 (var "m")
                 "\u2061"
                 "["
                 "11"
                 ","
                 "]"
                 ")"
                 ", "
                 "("
                 (var "m")
                 "\u2061"
                 "["
                 "12"
                 ","
                 "]"
                 " "
                 (var "m")
                 "\u2061"
                 "["
                 "13"
                 ","
                 "]"
                 " "
                 (var "m")
                 "\u2061"
                 "["
                 "14"
                 ","
                 "]"
                 " "
                 (var "m")
                 "\u2061"
                 "["
                 "15"
                 ","
                 "]"
                 ")"
                 ","
                 ")"
                 "×"
                 "("
                 "("
                 (var "v")
                 "\u2061"
                 "["
                 "0"
                 ","
                 "]"
                 ")"
                 ", "
                 "("
                 (var "v")
                 "\u2061"
                 "["
                 "1"
                 ","
                 "]"
                 ")"
                 ", "
                 "("
                 (var "v")
                 "\u2061"
                 "["
                 "2"
                 ","
                 "]"
                 ")"
                 ", "
                 "("
                 (var "v")
                 "\u2061"
                 "["
                 "3"
                 ","
                 "]"
                 ")"
                 ","
                 ")"))
     (para)
     (para "
Projection and texture transformations are similarly defined. ")
     (para "
Calling "
           (code "glLoadTransposeMatrix")
           " with matrix "
           (math (var "M"))
           "
is identical in operation to "
           (code "glLoadMatrix")
           " with "
           (math (var "M") "^" (var "T"))
           ",
            where "
           (math (var "T"))
           "
represents the transpose. ")
     (heading "Errors")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glLoadTransposeMatrix")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glLogicOp
  "glLogicOp"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glLogicOp"))
      (paramdef "GLenum " (parameter "opcode"))))
  '(*fragment*
     (heading
       "specify a logical pixel operation for color index rendering")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "opcode")))
                   (para "
Specifies a symbolic constant that selects a logical operation.
                    The following symbols are accepted: "
                         (code "GL_CLEAR")
                         ", "
                         (code "GL_SET")
                         ", "
                         (code "GL_COPY")
                         ", "
                         (code "GL_COPY_INVERTED")
                         ", "
                         (code "GL_NOOP")
                         ", "
                         (code "GL_INVERT")
                         ", "
                         (code "GL_AND")
                         ", "
                         (code "GL_NAND")
                         ", "
                         (code "GL_OR")
                         ", "
                         (code "GL_NOR")
                         ", "
                         (code "GL_XOR")
                         ", "
                         (code "GL_EQUIV")
                         ", "
                         (code "GL_AND_REVERSE")
                         ", "
                         (code "GL_AND_INVERTED")
                         ", "
                         (code "GL_OR_REVERSE")
                         ", and "
                         (code "GL_OR_INVERTED")
                         ". The initial value is "
                         (code "GL_COPY")
                         ". ")))
     (heading "Description")
     (para (code "glLogicOp")
           " specifies a logical operation that,
            when enabled,
            is applied between the incoming color index or RGBA color
            and the color index or RGBA color at the corresponding location in the
            frame buffer.
            To enable or disable the logical operation, call "
           (code "glEnable")
           " and "
           (code "glDisable")
           "
using the symbolic constant "
           (code "GL_COLOR_LOGIC_OP")
           " for RGBA mode or "
           (code "GL_INDEX_LOGIC_OP")
           " for color index mode. The initial value is
            disabled for both operations. ")
     (para)
     (table (% (formatter (asis)))
            (entry (% (heading (strong "Opcode")))
                   (para (strong "Resulting Operation")))
            (entry (% (heading (code "GL_CLEAR")))
                   (para "
0 "))
            (entry (% (heading (code "GL_SET")))
                   (para "
1 "))
            (entry (% (heading (code "GL_COPY")))
                   (para "
s "))
            (entry (% (heading (code "GL_COPY_INVERTED")))
                   (para "
~s "))
            (entry (% (heading (code "GL_NOOP")))
                   (para "
d "))
            (entry (% (heading (code "GL_INVERT")))
                   (para "
~d "))
            (entry (% (heading (code "GL_AND")))
                   (para "
s & d "))
            (entry (% (heading (code "GL_NAND")))
                   (para "
~(s & d) "))
            (entry (% (heading (code "GL_OR")))
                   (para "
s | d "))
            (entry (% (heading (code "GL_NOR")))
                   (para "
~(s | d) "))
            (entry (% (heading (code "GL_XOR")))
                   (para "
s ^ d "))
            (entry (% (heading (code "GL_EQUIV")))
                   (para "
~(s ^ d) "))
            (entry (% (heading (code "GL_AND_REVERSE")))
                   (para "
s & ~d "))
            (entry (% (heading (code "GL_AND_INVERTED")))
                   (para "
~s & d "))
            (entry (% (heading (code "GL_OR_REVERSE")))
                   (para "
s | ~d "))
            (entry (% (heading (code "GL_OR_INVERTED")))
                   (para "
~s | d ")))
     (para (var "opcode")
           " is a symbolic constant chosen from the list above.
            In the explanation of the logical operations, "
           (var "s")
           " represents the incoming color index and "
           (var "d")
           " represents the index in the frame buffer.
            Standard C-language operators are used.
            As these bitwise operators suggest,
            the logical operation is applied independently to each bit pair of the
            source and destination indices or colors. ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "opcode")
           " is not an accepted value. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glLogicOp")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glMap1
  "glMap1"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glMap1f"))
      (paramdef "GLenum " (parameter "target"))
      (paramdef "GLfloat " (parameter "u1"))
      (paramdef "GLfloat " (parameter "u2"))
      (paramdef "GLint " (parameter "stride"))
      (paramdef "GLint " (parameter "order"))
      (paramdef
        "const GLfloat * "
        (parameter "points"))))
  '(*fragment*
     (heading "define a one-dimensional evaluator")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "target")))
                   (para "
Specifies the kind of values that are generated by the evaluator.
                    Symbolic constants "
                         (code "GL_MAP1_VERTEX_3")
                         ", "
                         (code "GL_MAP1_VERTEX_4")
                         ", "
                         (code "GL_MAP1_INDEX")
                         ", "
                         (code "GL_MAP1_COLOR_4")
                         ", "
                         (code "GL_MAP1_NORMAL")
                         ", "
                         (code "GL_MAP1_TEXTURE_COORD_1")
                         ", "
                         (code "GL_MAP1_TEXTURE_COORD_2")
                         ", "
                         (code "GL_MAP1_TEXTURE_COORD_3")
                         ", and "
                         (code "GL_MAP1_TEXTURE_COORD_4")
                         " are accepted. "))
            (entry (% (heading (var "u1")))
                   (itemx (var "u2"))
                   (para "
Specify a linear mapping of "
                         (math (var "u"))
                         ",
                    as presented to "
                         (code "glEvalCoord1")
                         ",
                    to "
                         (math (var "u") "^")
                         ",
                    the variable that is evaluated by the equations specified by this command. "))
            (entry (% (heading (var "stride")))
                   (para "
Specifies the number of floats or doubles between
                    the beginning of one control point and the beginning of the next one
                    in the data structure referenced in "
                         (var "points")
                         ".
                    This allows control points to be embedded in arbitrary data structures.
                    The only constraint is that the values for a particular control point
                    must occupy contiguous memory locations. "))
            (entry (% (heading (var "order")))
                   (para "
Specifies the number of control points.
                    Must be positive. "))
            (entry (% (heading (var "points")))
                   (para "
Specifies a pointer to the array of control points. ")))
     (heading "Description")
     (para "
Evaluators provide a way to use polynomial or rational polynomial mapping
            to produce vertices,
            normals,
            texture coordinates,
            and colors.
            The values produced by an evaluator are sent to further stages
            of GL processing just as if they had been presented using "
           (code "glVertex")
           ", "
           (code "glNormal")
           ", "
           (code "glTexCoord")
           ", and "
           (code "glColor")
           " commands,
            except that the generated values do not update the current normal,
            texture coordinates,
            or color. ")
     (para "
All polynomial or rational polynomial splines of any degree
            (up to the maximum degree supported by the GL implementation)
            can be described using evaluators.
            These include almost all splines used in computer graphics: B-splines,
            Bezier curves, Hermite splines, and so on. ")
     (para "
Evaluators define curves based on Bernstein polynomials.
            Define "
           (math (var "p")
                 "\u2061"
                 "("
                 (var "u")
                 "^"
                 ","
                 ")")
           "
as ")
     (para (math (var "p")
                 "\u2061"
                 "("
                 (var "u")
                 "^"
                 ","
                 ")"
                 "="
                 "Σ"
                 (var "i")
                 "="
                 "0"
                 (var "n")
                 (var "B")
                 "_"
                 (var "i")
                 ","
                 "^"
                 (var "n")
                 "\u2061"
                 "("
                 (var "u")
                 "^"
                 ","
                 ")"
                 "\u2062"
                 (var "R")
                 "_"
                 (var "i")))
     (para)
     (para "
where "
           (math (var "R") "_" (var "i"))
           "
is a control point and "
           (math (var "B")
                 "_"
                 (var "i")
                 ","
                 "^"
                 (var "n")
                 "\u2061"
                 "("
                 (var "u")
                 "^"
                 ","
                 ")")
           "
is the "
           (math (var "i"))
           "th
            Bernstein polynomial of degree "
           (math (var "n"))
           "
("
           (var "order")
           " = "
           (math (var "n") "+" "1")
           "): ")
     (para (math (var "B")
                 "_"
                 (var "i")
                 ","
                 "^"
                 (var "n")
                 "\u2061"
                 "("
                 (var "u")
                 "^"
                 ","
                 ")"
                 "="
                 "("
                 "("
                 (var "n")
                 ")"
                 ", "
                 "("
                 (var "i")
                 ")"
                 ","
                 ","
                 ")"
                 "\u2062"
                 (var "u")
                 "^"
                 ","
                 "^"
                 (var "i")
                 "\u2062"
                 "("
                 "1"
                 "-"
                 (var "u")
                 "^"
                 ","
                 ")"
                 "^"
                 (var "n")
                 "-"
                 (var "i")
                 ","
                 ","))
     (para "
Recall that ")
     (para (math "0" "^" "0" "==" "1")
           "
and "
           (math "("
                 "("
                 (var "n")
                 ")"
                 ", "
                 "("
                 "0"
                 ")"
                 ","
                 ","
                 ")"
                 "=="
                 "1"))
     (para (code "glMap1")
           " is used to define the basis and to specify what kind of values
            are produced.
            Once defined,
            a map can be enabled and disabled by calling "
           (code "glEnable")
           " and "
           (code "glDisable")
           "
with the map name, one of the nine predefined values for "
           (var "target")
           "
described below. "
           (code "glEvalCoord1")
           " evaluates the one-dimensional maps that are enabled.
            When "
           (code "glEvalCoord1")
           " presents a value "
           (math (var "u"))
           ",
            the Bernstein functions are evaluated using "
           (math (var "u") "^")
           ",
            where "
           (math (var "u")
                 "^"
                 "="
                 (var "u")
                 "-"
                 (var "u1")
                 ","
                 "/"
                 (var "u2")
                 "-"
                 (var "u1")
                 ","))
     (para (var "target")
           " is a symbolic constant that indicates what kind of control points
            are provided in "
           (var "points")
           ",
            and what output is generated when the map is evaluated.
            It can assume one of nine predefined values: ")
     (table (% (formatter (asis)))
            (entry (% (heading (code "GL_MAP1_VERTEX_3")))
                   (para "
Each control point is three floating-point values representing "
                         (math (var "x"))
                         ", "
                         (math (var "y"))
                         ",
                        and "
                         (math (var "z"))
                         ".
                        Internal "
                         (code "glVertex3")
                         " commands are generated when the map is evaluated. "))
            (entry (% (heading (code "GL_MAP1_VERTEX_4")))
                   (para "
Each control point is four floating-point values representing "
                         (math (var "x"))
                         ", "
                         (math (var "y"))
                         ", "
                         (math (var "z"))
                         ",
                        and "
                         (math (var "w"))
                         ".
                        Internal "
                         (code "glVertex4")
                         " commands are generated when the map is evaluated. "))
            (entry (% (heading (code "GL_MAP1_INDEX")))
                   (para "
Each control point is a single floating-point value representing a color index.
                        Internal "
                         (code "glIndex")
                         " commands are generated when the map is evaluated
                        but the current index is not updated with the value of these "
                         (code "glIndex")
                         "
commands. "))
            (entry (% (heading (code "GL_MAP1_COLOR_4")))
                   (para "
Each control point is four floating-point values representing
                        red, green, blue, and alpha.
                        Internal "
                         (code "glColor4")
                         " commands are generated when the map is
                        evaluated but the current color is not updated with the value of these "
                         (code "glColor4")
                         " commands. "))
            (entry (% (heading (code "GL_MAP1_NORMAL")))
                   (para "
Each control point is three floating-point values representing
                        the "
                         (math (var "x"))
                         ", "
                         (math (var "y"))
                         ",
                        and "
                         (math (var "z"))
                         "
components of a normal vector.
                        Internal "
                         (code "glNormal")
                         " commands are generated when the map is
                        evaluated but the current normal is not updated with the value of
                        these "
                         (code "glNormal")
                         " commands. "))
            (entry (% (heading (code "GL_MAP1_TEXTURE_COORD_1")))
                   (para "
Each control point is a single floating-point value representing
                        the "
                         (math (var "s"))
                         "
texture coordinate.
                        Internal "
                         (code "glTexCoord1")
                         " commands are generated when the map is
                        evaluated but the current texture coordinates are not updated with the value
                        of these "
                         (code "glTexCoord")
                         " commands. "))
            (entry (% (heading (code "GL_MAP1_TEXTURE_COORD_2")))
                   (para "
Each control point is two floating-point values representing
                        the "
                         (math (var "s"))
                         "
and "
                         (math (var "t"))
                         "
texture coordinates.
                        Internal "
                         (code "glTexCoord2")
                         " commands are generated when the map is
                        evaluated but the current texture coordinates are not updated with the value
                        of these "
                         (code "glTexCoord")
                         " commands. "))
            (entry (% (heading (code "GL_MAP1_TEXTURE_COORD_3")))
                   (para "
Each control point is three floating-point values representing
                        the "
                         (math (var "s"))
                         ", "
                         (math (var "t"))
                         ",
                        and "
                         (math (var "r"))
                         "
texture coordinates.
                        Internal "
                         (code "glTexCoord3")
                         " commands are generated when the map is
                        evaluated but the current texture coordinates are not updated with the value
                        of these "
                         (code "glTexCoord")
                         " commands. "))
            (entry (% (heading (code "GL_MAP1_TEXTURE_COORD_4")))
                   (para "
Each control point is four floating-point values representing
                        the "
                         (math (var "s"))
                         ", "
                         (math (var "t"))
                         ", "
                         (math (var "r"))
                         ",
                        and "
                         (math (var "q"))
                         "
texture coordinates.
                        Internal "
                         (code "glTexCoord4")
                         " commands are generated when the map is evaluated but
                        the current texture coordinates are not updated with the value
                        of these "
                         (code "glTexCoord")
                         " commands. ")))
     (para (var "stride")
           ", "
           (var "order")
           ", and "
           (var "points")
           " define the array addressing for accessing the control points. "
           (var "points")
           " is the location of the first control point,
            which occupies one, two, three, or four contiguous memory locations,
            depending on which map is being defined. "
           (var "order")
           " is the number of control points in the array. "
           (var "stride")
           " specifies how many float or double locations to advance the internal
            memory pointer to reach the next control point. ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "target")
           " is not an accepted value. ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "u1")
           " is equal to "
           (var "u2")
           ". ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "stride")
           " is less than the number
            of values in a control point. ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "order")
           " is less than 1 or
            greater than the return value of "
           (code "GL_MAX_EVAL_ORDER")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glMap1")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glMap1")
           " is called and the value
            of "
           (code "GL_ACTIVE_TEXTURE")
           " is not "
           (code "GL_TEXTURE0")
           ". ")))

(define-gl-procedure
  glMap2
  "glMap2"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glMap2f"))
      (paramdef "GLenum " (parameter "target"))
      (paramdef "GLfloat " (parameter "u1"))
      (paramdef "GLfloat " (parameter "u2"))
      (paramdef "GLint " (parameter "ustride"))
      (paramdef "GLint " (parameter "uorder"))
      (paramdef "GLfloat " (parameter "v1"))
      (paramdef "GLfloat " (parameter "v2"))
      (paramdef "GLint " (parameter "vstride"))
      (paramdef "GLint " (parameter "vorder"))
      (paramdef
        "const GLfloat * "
        (parameter "points"))))
  '(*fragment*
     (heading "define a two-dimensional evaluator")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "target")))
                   (para "
Specifies the kind of values that are generated by the evaluator.
                    Symbolic constants "
                         (code "GL_MAP2_VERTEX_3")
                         ", "
                         (code "GL_MAP2_VERTEX_4")
                         ", "
                         (code "GL_MAP2_INDEX")
                         ", "
                         (code "GL_MAP2_COLOR_4")
                         ", "
                         (code "GL_MAP2_NORMAL")
                         ", "
                         (code "GL_MAP2_TEXTURE_COORD_1")
                         ", "
                         (code "GL_MAP2_TEXTURE_COORD_2")
                         ", "
                         (code "GL_MAP2_TEXTURE_COORD_3")
                         ", and "
                         (code "GL_MAP2_TEXTURE_COORD_4")
                         " are accepted. "))
            (entry (% (heading (var "u1")))
                   (itemx (var "u2"))
                   (para "
Specify a linear mapping of "
                         (math (var "u"))
                         ",
                    as presented to "
                         (code "glEvalCoord2")
                         ",
                    to "
                         (math (var "u") "^")
                         ",
                    one of the two variables that are evaluated by the equations specified
                    by this command. Initially, "
                         (var "u1")
                         " is 0 and "
                         (var "u2")
                         " is 1. "))
            (entry (% (heading (var "ustride")))
                   (para "
Specifies the number of floats or doubles between
                    the beginning of control point "
                         (math (var "R") "_" (var "ij"))
                         "
and the beginning of control point "
                         (math (var "R")
                               "_"
                               "("
                               (var "i")
                               "+"
                               "1"
                               ","
                               ")"
                               "\u2062"
                               (var "j")
                               ",")
                         ",
                    where "
                         (math (var "i"))
                         "
and "
                         (math (var "j"))
                         "
are the "
                         (math (var "u"))
                         "
and "
                         (math (var "v"))
                         "
control point indices, respectively.
                    This allows control points to be embedded in arbitrary data structures.
                    The only constraint is that the values for a particular control point
                    must occupy contiguous memory locations. The initial value of "
                         (var "ustride")
                         " is 0. "))
            (entry (% (heading (var "uorder")))
                   (para "
Specifies the dimension of the control point array in the "
                         (math (var "u"))
                         "
axis.
                    Must be positive. The initial value is 1. "))
            (entry (% (heading (var "v1")))
                   (itemx (var "v2"))
                   (para "
Specify a linear mapping of "
                         (math (var "v"))
                         ",
                    as presented to "
                         (code "glEvalCoord2")
                         ",
                    to "
                         (math (var "v") "^")
                         ",
                    one of the two variables that are evaluated by the equations specified
                    by this command. Initially, "
                         (var "v1")
                         " is 0 and "
                         (var "v2")
                         " is 1. "))
            (entry (% (heading (var "vstride")))
                   (para "
Specifies the number of floats or doubles between
                    the beginning of control point "
                         (math (var "R") "_" (var "ij"))
                         "
and the beginning of control point "
                         (math (var "R")
                               "_"
                               (var "i")
                               "\u2061"
                               "("
                               (var "j")
                               "+"
                               "1"
                               ","
                               ")"
                               ",")
                         ",
                    where "
                         (math (var "i"))
                         "
and "
                         (math (var "j"))
                         "
are the "
                         (math (var "u"))
                         "
and "
                         (math (var "v"))
                         "
control point indices, respectively.
                    This allows control points to be embedded in arbitrary data structures.
                    The only constraint is that the values for a particular control point
                    must occupy contiguous memory locations. The initial value of "
                         (var "vstride")
                         " is 0. "))
            (entry (% (heading (var "vorder")))
                   (para "
Specifies the dimension of the control point array in the "
                         (math (var "v"))
                         "
axis.
                    Must be positive. The initial value is 1. "))
            (entry (% (heading (var "points")))
                   (para "
Specifies a pointer to the array of control points. ")))
     (heading "Description")
     (para "
Evaluators provide a way to use polynomial or rational polynomial mapping
            to produce vertices,
            normals,
            texture coordinates,
            and colors.
            The values produced by an evaluator are sent on to further stages
            of GL processing just as if they had been presented using "
           (code "glVertex")
           ", "
           (code "glNormal")
           ", "
           (code "glTexCoord")
           ", and "
           (code "glColor")
           " commands,
            except that the generated values do not update the current normal,
            texture coordinates,
            or color. ")
     (para "
All polynomial or rational polynomial splines of any degree
            (up to the maximum degree supported by the GL implementation)
            can be described using evaluators.
            These include almost all surfaces used in computer graphics,
            including B-spline surfaces,
            NURBS surfaces,
            Bezier surfaces, and so on. ")
     (para "
Evaluators define surfaces based on bivariate Bernstein polynomials.
            Define "
           (math (var "p")
                 "\u2061"
                 "("
                 (var "u")
                 "^"
                 ","
                 (var "v")
                 "^"
                 ")")
           "
as ")
     (para (math (var "p")
                 "\u2061"
                 "("
                 (var "u")
                 "^"
                 ","
                 (var "v")
                 "^"
                 ")"
                 "="
                 "Σ"
                 (var "i")
                 "="
                 "0"
                 (var "n")
                 "Σ"
                 (var "j")
                 "="
                 "0"
                 (var "m")
                 (var "B")
                 "_"
                 (var "i")
                 ","
                 "^"
                 (var "n")
                 "\u2061"
                 "("
                 (var "u")
                 "^"
                 ","
                 ")"
                 "\u2062"
                 (var "B")
                 "_"
                 (var "j")
                 ","
                 "^"
                 (var "m")
                 "\u2061"
                 "("
                 (var "v")
                 "^"
                 ","
                 ")"
                 "\u2062"
                 (var "R")
                 "_"
                 (var "ij")))
     (para)
     (para "
where "
           (math (var "R") "_" (var "ij"))
           "
is a control point, "
           (math (var "B")
                 "_"
                 (var "i")
                 ","
                 "^"
                 (var "n")
                 "\u2061"
                 "("
                 (var "u")
                 "^"
                 ","
                 ")")
           "
is the "
           (math (var "i"))
           "th
            Bernstein polynomial of degree "
           (math (var "n"))
           "
("
           (var "uorder")
           " = "
           (math (var "n") "+" "1")
           ") ")
     (para (math (var "B")
                 "_"
                 (var "i")
                 ","
                 "^"
                 (var "n")
                 "\u2061"
                 "("
                 (var "u")
                 "^"
                 ","
                 ")"
                 "="
                 "("
                 "("
                 (var "n")
                 ")"
                 ", "
                 "("
                 (var "i")
                 ")"
                 ","
                 ","
                 ")"
                 "\u2062"
                 (var "u")
                 "^"
                 ","
                 "^"
                 (var "i")
                 "\u2062"
                 "("
                 "1"
                 "-"
                 (var "u")
                 "^"
                 ","
                 ")"
                 "^"
                 (var "n")
                 "-"
                 (var "i")
                 ","
                 ","))
     (para "
and "
           (math (var "B")
                 "_"
                 (var "j")
                 ","
                 "^"
                 (var "m")
                 "\u2061"
                 "("
                 (var "v")
                 "^"
                 ","
                 ")")
           "
is the "
           (math (var "j"))
           "th
            Bernstein polynomial of degree "
           (math (var "m"))
           "
("
           (var "vorder")
           " = "
           (math (var "m") "+" "1")
           ") ")
     (para (math (var "B")
                 "_"
                 (var "j")
                 ","
                 "^"
                 (var "m")
                 "\u2061"
                 "("
                 (var "v")
                 "^"
                 ","
                 ")"
                 "="
                 "("
                 "("
                 (var "m")
                 ")"
                 ", "
                 "("
                 (var "j")
                 ")"
                 ","
                 ","
                 ")"
                 "\u2062"
                 (var "v")
                 "^"
                 ","
                 "^"
                 (var "j")
                 "\u2062"
                 "("
                 "1"
                 "-"
                 (var "v")
                 "^"
                 ","
                 ")"
                 "^"
                 (var "m")
                 "-"
                 (var "j")
                 ","
                 ","))
     (para "
Recall that "
           (math "0" "^" "0" "==" "1")
           "
and "
           (math "("
                 "("
                 (var "n")
                 ")"
                 ", "
                 "("
                 "0"
                 ")"
                 ","
                 ","
                 ")"
                 "=="
                 "1"))
     (para (code "glMap2")
           " is used to define the basis and to specify what kind of values
            are produced.
            Once defined,
            a map can be enabled and disabled by calling "
           (code "glEnable")
           " and "
           (code "glDisable")
           "
with the map name, one of the nine predefined values for "
           (var "target")
           ",
            described below.
            When "
           (code "glEvalCoord2")
           " presents values "
           (math (var "u"))
           "
and "
           (math (var "v"))
           ",
            the bivariate Bernstein polynomials are evaluated using "
           (math (var "u") "^")
           "
and "
           (math (var "v") "^")
           ",
            where ")
     (para (math (var "u")
                 "^"
                 "="
                 (var "u")
                 "-"
                 (var "u1")
                 ","
                 "/"
                 (var "u2")
                 "-"
                 (var "u1")
                 ","))
     (para (math (var "v")
                 "^"
                 "="
                 (var "v")
                 "-"
                 (var "v1")
                 ","
                 "/"
                 (var "v2")
                 "-"
                 (var "v1")
                 ","))
     (para (var "target")
           " is a symbolic constant that indicates what kind of control points
            are provided in "
           (var "points")
           ",
            and what output is generated when the map is evaluated.
            It can assume one of nine predefined values: ")
     (table (% (formatter (asis)))
            (entry (% (heading (code "GL_MAP2_VERTEX_3")))
                   (para "
Each control point is three floating-point values representing "
                         (math (var "x"))
                         ", "
                         (math (var "y"))
                         ",
                        and "
                         (math (var "z"))
                         ".
                        Internal "
                         (code "glVertex3")
                         " commands are generated when the map is evaluated. "))
            (entry (% (heading (code "GL_MAP2_VERTEX_4")))
                   (para "
Each control point is four floating-point values representing "
                         (math (var "x"))
                         ", "
                         (math (var "y"))
                         ", "
                         (math (var "z"))
                         ",
                        and "
                         (math (var "w"))
                         ".
                        Internal "
                         (code "glVertex4")
                         " commands are generated when the map is evaluated. "))
            (entry (% (heading (code "GL_MAP2_INDEX")))
                   (para "
Each control point is a single floating-point value representing a color index.
                        Internal "
                         (code "glIndex")
                         " commands are generated when the map is evaluated
                        but the current index is not updated with the value of these "
                         (code "glIndex")
                         " commands. "))
            (entry (% (heading (code "GL_MAP2_COLOR_4")))
                   (para "
Each control point is four floating-point values representing
                        red, green, blue, and alpha.
                        Internal "
                         (code "glColor4")
                         " commands are generated when the map is
                        evaluated but the current color is not updated with the value of
                        these "
                         (code "glColor4")
                         " commands. "))
            (entry (% (heading (code "GL_MAP2_NORMAL")))
                   (para "
Each control point is three floating-point values representing
                        the "
                         (math (var "x"))
                         ", "
                         (math (var "y"))
                         ",
                        and "
                         (math (var "z"))
                         "
components of a normal vector.
                        Internal "
                         (code "glNormal")
                         " commands are generated when the map is
                        evaluated but the current normal is not updated with the value of
                        these "
                         (code "glNormal")
                         " commands. "))
            (entry (% (heading (code "GL_MAP2_TEXTURE_COORD_1")))
                   (para "
Each control point is a single floating-point value representing
                        the "
                         (math (var "s"))
                         "
texture coordinate.
                        Internal "
                         (code "glTexCoord1")
                         " commands are generated when the map is evaluated but
                        the current texture coordinates are not updated with the value
                        of these "
                         (code "glTexCoord")
                         " commands. "))
            (entry (% (heading (code "GL_MAP2_TEXTURE_COORD_2")))
                   (para "
Each control point is two floating-point values representing
                        the "
                         (math (var "s"))
                         "
and "
                         (math (var "t"))
                         "
texture coordinates.
                        Internal "
                         (code "glTexCoord2")
                         " commands are generated when the map is evaluated but
                        the current texture coordinates are not updated with the value
                        of these "
                         (code "glTexCoord")
                         " commands. "))
            (entry (% (heading (code "GL_MAP2_TEXTURE_COORD_3")))
                   (para "
Each control point is three floating-point values representing
                        the "
                         (math (var "s"))
                         ", "
                         (math (var "t"))
                         ",
                        and "
                         (math (var "r"))
                         "
texture coordinates.
                        Internal "
                         (code "glTexCoord3")
                         " commands are generated when the map is
                        evaluated but the current texture coordinates are not updated with the value
                        of these "
                         (code "glTexCoord")
                         " commands. "))
            (entry (% (heading (code "GL_MAP2_TEXTURE_COORD_4")))
                   (para "
Each control point is four floating-point values representing
                        the "
                         (math (var "s"))
                         ", "
                         (math (var "t"))
                         ", "
                         (math (var "r"))
                         ",
                        and "
                         (math (var "q"))
                         "
texture coordinates.
                        Internal "
                         (code "glTexCoord4")
                         " commands are generated when the map is evaluated but the current texture coordinates are not updated with the value
                        of these "
                         (code "glTexCoord")
                         " commands. ")))
     (para (var "ustride")
           ", "
           (var "uorder")
           ", "
           (var "vstride")
           ", "
           (var "vorder")
           ", and "
           (var "points")
           " define the array addressing for accessing the control points. "
           (var "points")
           " is the location of the first control point,
            which occupies one, two, three, or four contiguous memory locations,
            depending on which map is being defined.
            There are "
           (math (var "uorder") "×" (var "vorder"))
           "
control points in the array. "
           (var "ustride")
           " specifies how many float or double locations are skipped to advance
            the internal memory pointer from control point "
           (math (var "R")
                 "_"
                 (var "i")
                 "\u2062"
                 (var "j")
                 ",")
           "
to control point "
           (math (var "R")
                 "_"
                 "("
                 (var "i")
                 "+"
                 "1"
                 ","
                 ")"
                 "\u2062"
                 (var "j")
                 ",")
           ". "
           (var "vstride")
           " specifies how many float or double locations are skipped to advance
            the internal memory pointer from control point "
           (math (var "R")
                 "_"
                 (var "i")
                 "\u2062"
                 (var "j")
                 ",")
           "
to control point "
           (math (var "R")
                 "_"
                 (var "i")
                 "\u2061"
                 "("
                 (var "j")
                 "+"
                 "1"
                 ","
                 ")"
                 ",")
           ". ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "target")
           " is not an accepted value. ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "u1")
           " is equal to "
           (var "u2")
           ",
            or if "
           (var "v1")
           " is equal to "
           (var "v2")
           ". ")
     (para (code "GL_INVALID_VALUE")
           " is generated if either "
           (var "ustride")
           " or "
           (var "vstride")
           "
is less than the number of values in a control point. ")
     (para (code "GL_INVALID_VALUE")
           " is generated if either "
           (var "uorder")
           " or "
           (var "vorder")
           "
is less than 1 or greater than the return value of "
           (code "GL_MAX_EVAL_ORDER")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glMap2")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glMap2")
           " is called and the value
            of "
           (code "GL_ACTIVE_TEXTURE")
           " is not "
           (code "GL_TEXTURE0")
           ". ")))

(define-gl-procedure
  glMapBuffer
  "glMapBuffer"
  (funcsynopsis
    (funcprototype
      (funcdef "void * " (function "glMapBuffer"))
      (paramdef "GLenum " (parameter "target"))
      (paramdef "GLenum " (parameter "access"))))
  '(*fragment*
     (heading "map a buffer object's data store")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "target")))
                   (para "
Specifies the target buffer object being mapped.
                    The symbolic constant must be "
                         (code "GL_ARRAY_BUFFER")
                         ", "
                         (code "GL_ELEMENT_ARRAY_BUFFER")
                         ", "
                         (code "GL_PIXEL_PACK_BUFFER")
                         ", or "
                         (code "GL_PIXEL_UNPACK_BUFFER")
                         ". "))
            (entry (% (heading (var "access")))
                   (para "
Specifies the access policy, indicating whether it will be possible to read from, write to,
                    or both read from and write to the buffer object's mapped data store. The symbolic constant must be "
                         (code "GL_READ_ONLY")
                         ", "
                         (code "GL_WRITE_ONLY")
                         ", or "
                         (code "GL_READ_WRITE")
                         ". ")))
     (heading "Description")
     (para (code "glMapBuffer")
           " maps to the client's address space the entire data store of the buffer object 
            currently bound to "
           (var "target")
           ". The data can then be directly read and/or written relative to 
            the returned pointer, depending on the specified "
           (var "access")
           " policy. If the GL is unable to
            map the buffer object's data store, "
           (code "glMapBuffer")
           " generates an error and returns "
           (code "NULL")
           ". This may occur for system-specific reasons, such as low virtual memory availability. ")
     (para "
If a mapped data store is accessed in a way inconsistent with the specified "
           (var "access")
           " policy,
            no error is generated, but performance may be negatively impacted and system errors, including program 
            termination, may result. Unlike the "
           (var "usage")
           " parameter of "
           (code "glBufferData")
           ", "
           (var "access")
           " is not a hint, and does in fact constrain the usage of the mapped data store on
            some GL implementations. In order to achieve the highest performance available, a buffer object's data store 
            should be used in ways consistent with both its specified "
           (var "usage")
           " and "
           (var "access")
           " parameters. ")
     (para "
A mapped data store must be unmapped with "
           (code "glUnmapBuffer")
           " before its buffer object is used.
            Otherwise an error will be generated by any GL command that attempts to dereference the buffer object's data store.
            When a data store is unmapped, the pointer to its data store becomes invalid. "
           (code "glUnmapBuffer")
           "
returns "
           (code "GL_TRUE")
           " unless the data store contents have become corrupt during the time
            the data store was mapped. This can occur for system-specific reasons that affect the availability of graphics
            memory, such as screen mode changes. In such situations, "
           (code "GL_FALSE")
           " is returned and the
            data store contents are undefined. An application must detect this rare condition and reinitialize the data store. ")
     (para "
A buffer object's mapped data store is automatically unmapped when the buffer object is deleted or its data store 
            is recreated with "
           (code "glBufferData")
           ". ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "target")
           " is not "
           (code "GL_ARRAY_BUFFER")
           ", "
           (code "GL_ELEMENT_ARRAY_BUFFER")
           ", "
           (code "GL_PIXEL_PACK_BUFFER")
           ", or "
           (code "GL_PIXEL_UNPACK_BUFFER")
           ". ")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "access")
           " is not "
           (code "GL_READ_ONLY")
           ", "
           (code "GL_WRITE_ONLY")
           ", or "
           (code "GL_READ_WRITE")
           ". ")
     (para (code "GL_OUT_OF_MEMORY")
           " is generated when "
           (code "glMapBuffer")
           " is executed
            if the GL is unable to map the buffer object's data store. This may occur for a variety of system-specific 
            reasons, such as the absence of sufficient remaining virtual memory. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if the reserved buffer object name 0 is bound to "
           (var "target")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glMapBuffer")
           " is executed for
            a buffer object whose data store is already mapped. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glUnmapBuffer")
           " is executed for
            a buffer object whose data store is not currently mapped. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glMapBuffer")
           " or "
           (code "glUnmapBuffer")
           " is executed
            between the execution of "
           (code "glBegin")
           " and the corresponding
            execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glMapGrid
  "glMapGrid"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glMapGrid1d"))
      (paramdef "GLint " (parameter "un"))
      (paramdef "GLdouble " (parameter "u1"))
      (paramdef "GLdouble " (parameter "u2"))))
  '(*fragment*
     (heading "define a one- or two-dimensional mesh")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "un")))
                   (para "
Specifies the number of partitions in the grid range interval
                    ["
                         (var "u1")
                         ", "
                         (var "u2")
                         "].
                    Must be positive. "))
            (entry (% (heading (var "u1")))
                   (itemx (var "u2"))
                   (para "
Specify the mappings for integer grid domain values "
                         (math (var "i") "=" "0")
                         "
and "
                         (math (var "i") "=" (var "un"))
                         ". "))
            (entry (% (heading (var "vn")))
                   (para "
Specifies the number of partitions in the grid range interval
                    ["
                         (var "v1")
                         ", "
                         (var "v2")
                         "]
                    ("
                         (code "glMapGrid2")
                         " only). "))
            (entry (% (heading (var "v1")))
                   (itemx (var "v2"))
                   (para "
Specify the mappings for integer grid domain values "
                         (math (var "j") "=" "0")
                         "
and "
                         (math (var "j") "=" (var "vn"))
                         "
("
                         (code "glMapGrid2")
                         " only). ")))
     (heading "Description")
     (para (code "glMapGrid")
           " and "
           (code "glEvalMesh")
           " are used together to efficiently
            generate and evaluate a series of evenly-spaced map domain values. "
           (code "glEvalMesh")
           " steps through the integer domain
            of a one- or two-dimensional grid,
            whose range is the domain of the evaluation maps specified by "
           (code "glMap1")
           " and "
           (code "glMap2")
           ". ")
     (para (code "glMapGrid1")
           " and "
           (code "glMapGrid2")
           " specify the linear grid mappings
            between the "
           (math (var "i"))
           "
(or "
           (math (var "i"))
           "
and "
           (math (var "j"))
           ")
            integer grid coordinates,
            to the "
           (math (var "u"))
           "
(or "
           (math (var "u"))
           "
and "
           (math (var "v"))
           ")
            floating-point evaluation map coordinates.
            See "
           (code "glMap1")
           " and "
           (code "glMap2")
           " for details of how "
           (math (var "u"))
           "
and "
           (math (var "v"))
           "
coordinates
            are evaluated. ")
     (para (code "glMapGrid1")
           " specifies a single linear mapping
            such that integer grid coordinate 0 maps exactly to "
           (var "u1")
           ",
            and integer grid coordinate "
           (var "un")
           " maps exactly to "
           (var "u2")
           ".
            All other integer grid coordinates "
           (math (var "i"))
           "
are mapped so that ")
     (para (math (var "u")
                 "="
                 (var "i")
                 "\u2061"
                 "("
                 (var "u2")
                 "-"
                 (var "u1")
                 ","
                 ")"
                 "/"
                 (var "un")
                 "+"
                 (var "u1")))
     (para (code "glMapGrid2")
           " specifies two such linear mappings.
            One maps integer grid coordinate "
           (math (var "i") "=" "0")
           "
exactly to "
           (var "u1")
           ",
            and integer grid coordinate "
           (math (var "i") "=" (var "un"))
           "
exactly to "
           (var "u2")
           ".
            The other maps integer grid coordinate "
           (math (var "j") "=" "0")
           "
exactly to "
           (var "v1")
           ",
            and integer grid coordinate "
           (math (var "j") "=" (var "vn"))
           "
exactly to "
           (var "v2")
           ".
            Other integer grid coordinates "
           (math (var "i"))
           "
and "
           (math (var "j"))
           "
are mapped such that ")
     (para (math (var "u")
                 "="
                 (var "i")
                 "\u2061"
                 "("
                 (var "u2")
                 "-"
                 (var "u1")
                 ","
                 ")"
                 "/"
                 (var "un")
                 "+"
                 (var "u1")))
     (para (math (var "v")
                 "="
                 (var "j")
                 "\u2061"
                 "("
                 (var "v2")
                 "-"
                 (var "v1")
                 ","
                 ")"
                 "/"
                 (var "vn")
                 "+"
                 (var "v1")))
     (para "
The mappings specified by "
           (code "glMapGrid")
           " are used identically by "
           (code "glEvalMesh")
           " and "
           (code "glEvalPoint")
           ". ")
     (heading "Errors")
     (para (code "GL_INVALID_VALUE")
           " is generated if either "
           (var "un")
           " or "
           (var "vn")
           " is not
            positive. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glMapGrid")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glMaterial
  "glMaterial"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glMaterialf"))
      (paramdef "GLenum " (parameter "face"))
      (paramdef "GLenum " (parameter "pname"))
      (paramdef "GLfloat " (parameter "param"))))
  '(*fragment*
     (heading
       "specify material parameters for the lighting model")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "face")))
                   (para "
Specifies which face or faces are being updated.
                    Must be one of "
                         (code "GL_FRONT")
                         ", "
                         (code "GL_BACK")
                         ", or "
                         (code "GL_FRONT_AND_BACK")
                         ". "))
            (entry (% (heading (var "pname")))
                   (para "
Specifies the single-valued material parameter of the face or faces
                    that is being updated.
                    Must be "
                         (code "GL_SHININESS")
                         ". "))
            (entry (% (heading (var "param")))
                   (para "
Specifies the value that parameter "
                         (code "GL_SHININESS")
                         " will be set to. ")))
     (heading "Description")
     (para (code "glMaterial")
           " assigns values to material parameters.
            There are two matched sets of material parameters.
            One,
            the "
           (var "front-facing")
           " set,
            is used to shade points,
            lines,
            bitmaps,
            and all polygons
            (when two-sided lighting is disabled),
            or just front-facing polygons
            (when two-sided lighting is enabled).
            The other set, "
           (var "back-facing")
           ",
            is used to shade back-facing polygons only when two-sided lighting is enabled.
            Refer to the "
           (code "glLightModel")
           " reference page for details concerning one- and
            two-sided lighting calculations. ")
     (para (code "glMaterial")
           " takes three arguments.
            The first, "
           (var "face")
           ",
            specifies whether the "
           (code "GL_FRONT")
           " materials, the "
           (code "GL_BACK")
           " materials, or both "
           (code "GL_FRONT_AND_BACK")
           " materials will be modified.
            The second, "
           (var "pname")
           ",
            specifies which of several parameters in one or both sets will be modified.
            The third, "
           (var "params")
           ",
            specifies what value or values will be assigned to the specified parameter. ")
     (para "
Material parameters are used in the lighting equation that is optionally
            applied to each vertex.
            The equation is discussed in the "
           (code "glLightModel")
           " reference page.
            The parameters that can be specified using "
           (code "glMaterial")
           ",
            and their interpretations by the lighting equation, are as follows: ")
     (table (% (formatter (asis)))
            (entry (% (heading (code "GL_AMBIENT")))
                   (para (var "params")
                         " contains four integer or floating-point values that specify
                        the ambient RGBA reflectance of the material.
                        Integer values are mapped linearly such that the most positive representable
                        value maps to 1.0,
                        and the most negative representable value maps to "
                         (math "-1.0")
                         ".
                        Floating-point values are mapped directly.
                        Neither integer nor floating-point values are clamped.
                        The initial ambient reflectance for both front- and back-facing materials
                        is (0.2, 0.2, 0.2, 1.0). "))
            (entry (% (heading (code "GL_DIFFUSE")))
                   (para (var "params")
                         " contains four integer or floating-point values that specify
                        the diffuse RGBA reflectance of the material.
                        Integer values are mapped linearly such that the most positive representable
                        value maps to 1.0,
                        and the most negative representable value maps to "
                         (math "-1.0")
                         ".
                        Floating-point values are mapped directly.
                        Neither integer nor floating-point values are clamped.
                        The initial diffuse reflectance for both front- and back-facing materials
                        is (0.8, 0.8, 0.8, 1.0). "))
            (entry (% (heading (code "GL_SPECULAR")))
                   (para (var "params")
                         " contains four integer or floating-point values that specify
                        the specular RGBA reflectance of the material.
                        Integer values are mapped linearly such that the most positive representable
                        value maps to 1.0,
                        and the most negative representable value maps to "
                         (math "-1.0")
                         ".
                        Floating-point values are mapped directly.
                        Neither integer nor floating-point values are clamped.
                        The initial specular reflectance for both front- and back-facing materials
                        is (0, 0, 0, 1). "))
            (entry (% (heading (code "GL_EMISSION")))
                   (para (var "params")
                         " contains four integer or floating-point values that specify
                        the RGBA emitted light intensity of the material.
                        Integer values are mapped linearly such that the most positive representable
                        value maps to 1.0,
                        and the most negative representable value maps to "
                         (math "-1.0")
                         ".
                        Floating-point values are mapped directly.
                        Neither integer nor floating-point values are clamped.
                        The initial emission intensity for both front- and back-facing materials
                        is (0, 0, 0, 1). "))
            (entry (% (heading (code "GL_SHININESS")))
                   (para (var "params")
                         " is a single integer or floating-point value that specifies
                        the RGBA specular exponent of the material.
                        Integer and floating-point values are mapped directly.
                        Only values in the range "
                         (math "[" "0" "," "128" "]")
                         "
are accepted.
                        The initial specular exponent for both front- and back-facing materials
                        is 0. "))
            (entry (% (heading (code "GL_AMBIENT_AND_DIFFUSE")))
                   (para "
Equivalent to calling "
                         (code "glMaterial")
                         " twice with the same parameter values,
                        once with "
                         (code "GL_AMBIENT")
                         " and once with "
                         (code "GL_DIFFUSE")
                         ". "))
            (entry (% (heading (code "GL_COLOR_INDEXES")))
                   (para (var "params")
                         " contains three integer or floating-point values specifying
                        the color indices for ambient,
                        diffuse,
                        and specular lighting.
                        These three values,
                        and "
                         (code "GL_SHININESS")
                         ",
                        are the only material values used by the color index mode lighting equation.
                        Refer to the "
                         (code "glLightModel")
                         " reference page for a discussion
                        of color index lighting. ")))
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if either "
           (var "face")
           " or "
           (var "pname")
           " is not
            an accepted value. ")
     (para (code "GL_INVALID_VALUE")
           " is generated if a specular exponent outside the range "
           (math "[" "0" "," "128" "]")
           "
is specified. ")))

(define-gl-procedure
  glMatrixMode
  "glMatrixMode"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glMatrixMode"))
      (paramdef "GLenum " (parameter "mode"))))
  '(*fragment*
     (heading
       "specify which matrix is the current matrix")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "mode")))
                   (para "
Specifies which matrix stack is the target
                    for subsequent matrix operations.
                    Three values are accepted: "
                         (code "GL_MODELVIEW")
                         ", "
                         (code "GL_PROJECTION")
                         ", and "
                         (code "GL_TEXTURE")
                         ".
                    The initial value is "
                         (code "GL_MODELVIEW")
                         ".
                    Additionally, if the "
                         (code "ARB_imaging")
                         " extension is supported, "
                         (code "GL_COLOR")
                         " is also accepted. ")))
     (heading "Description")
     (para (code "glMatrixMode")
           " sets the current matrix mode. "
           (var "mode")
           " can assume one of four values: ")
     (table (% (formatter (asis)))
            (entry (% (heading (code "GL_MODELVIEW")))
                   (para "
Applies subsequent matrix operations to the modelview matrix stack. "))
            (entry (% (heading (code "GL_PROJECTION")))
                   (para "
Applies subsequent matrix operations to the projection matrix stack. "))
            (entry (% (heading (code "GL_TEXTURE")))
                   (para "
Applies subsequent matrix operations to the texture matrix stack. "))
            (entry (% (heading (code "GL_COLOR")))
                   (para "
Applies subsequent matrix operations to the color matrix stack. ")))
     (para "
To find out which matrix stack is currently the target of all matrix
            operations, call "
           (code "glGet")
           " with argument "
           (code "GL_MATRIX_MODE")
           ". The initial
            value is "
           (code "GL_MODELVIEW")
           ". ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "mode")
           " is not an accepted value. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glMatrixMode")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glMinmax
  "glMinmax"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glMinmax"))
      (paramdef "GLenum " (parameter "target"))
      (paramdef "GLenum " (parameter "internalformat"))
      (paramdef "GLboolean " (parameter "sink"))))
  '(*fragment*
     (heading "define minmax table")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "target")))
                   (para "
The minmax table whose parameters are to be set.
                    Must be "
                         (code "GL_MINMAX")
                         ". "))
            (entry (% (heading (var "internalformat")))
                   (para "
The format of entries in the minmax table.
                    Must be one of "
                         (code "GL_ALPHA")
                         ", "
                         (code "GL_ALPHA4")
                         ", "
                         (code "GL_ALPHA8")
                         ", "
                         (code "GL_ALPHA12")
                         ", "
                         (code "GL_ALPHA16")
                         ", "
                         (code "GL_LUMINANCE")
                         ", "
                         (code "GL_LUMINANCE4")
                         ", "
                         (code "GL_LUMINANCE8")
                         ", "
                         (code "GL_LUMINANCE12")
                         ", "
                         (code "GL_LUMINANCE16")
                         ", "
                         (code "GL_LUMINANCE_ALPHA")
                         ", "
                         (code "GL_LUMINANCE4_ALPHA4")
                         ", "
                         (code "GL_LUMINANCE6_ALPHA2")
                         ", "
                         (code "GL_LUMINANCE8_ALPHA8")
                         ", "
                         (code "GL_LUMINANCE12_ALPHA4")
                         ", "
                         (code "GL_LUMINANCE12_ALPHA12")
                         ", "
                         (code "GL_LUMINANCE16_ALPHA16")
                         ", "
                         (code "GL_R3_G3_B2")
                         ", "
                         (code "GL_RGB")
                         ", "
                         (code "GL_RGB4")
                         ", "
                         (code "GL_RGB5")
                         ", "
                         (code "GL_RGB8")
                         ", "
                         (code "GL_RGB10")
                         ", "
                         (code "GL_RGB12")
                         ", "
                         (code "GL_RGB16")
                         ", "
                         (code "GL_RGBA")
                         ", "
                         (code "GL_RGBA2")
                         ", "
                         (code "GL_RGBA4")
                         ", "
                         (code "GL_RGB5_A1")
                         ", "
                         (code "GL_RGBA8")
                         ", "
                         (code "GL_RGB10_A2")
                         ", "
                         (code "GL_RGBA12")
                         ", or "
                         (code "GL_RGBA16")
                         ". "))
            (entry (% (heading (var "sink")))
                   (para "
If "
                         (code "GL_TRUE")
                         ", pixels will be consumed by the minmax
                    process and no drawing or texture loading will take place.
                    If "
                         (code "GL_FALSE")
                         ", pixels will proceed to the final conversion process after
                    minmax. ")))
     (heading "Description")
     (para "
When "
           (code "GL_MINMAX")
           " is enabled, the RGBA components of incoming pixels are
            compared to the minimum and maximum values for each component, which are
            stored in the two-element minmax table.
            (The first element stores the minima, and the second element stores
            the maxima.)
            If a pixel component is greater than the corresponding component
            in the maximum element, then the maximum element is updated with the
            pixel component value.
            If a pixel component is less than the corresponding component in
            the minimum element, then the minimum element is updated with the
            pixel component value.
            (In both cases, if the internal format of the minmax table includes
            luminance, then the R color component of incoming pixels is used
            for comparison.)
            The contents of the minmax table may be retrieved at a later time
            by calling "
           (code "glGetMinmax")
           ".
            The minmax operation is enabled or disabled by calling "
           (code "glEnable")
           " or "
           (code "glDisable")
           ", respectively, with an argument of "
           (code "GL_MINMAX")
           ". ")
     (para (code "glMinmax")
           " redefines the current minmax table to have entries of the format
            specified by "
           (var "internalformat")
           ".
            The maximum element is initialized with the smallest possible component
            values, and the minimum element is initialized with the largest possible
            component values.
            The values in the previous minmax table, if any, are lost.
            If "
           (var "sink")
           " is "
           (code "GL_TRUE")
           ", then pixels are discarded after minmax;
            no further processing of the pixels takes place, and no drawing,
            texture loading, or pixel readback will result. ")
     (para)
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "target")
           " is not one of the allowable
            values. ")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "internalformat")
           " is not one of the
            allowable values. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glMinmax")
           " is executed
            between the execution of "
           (code "glBegin")
           " and the corresponding
            execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glMultiDrawArrays
  "glMultiDrawArrays"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glMultiDrawArrays"))
      (paramdef "GLenum " (parameter "mode"))
      (paramdef "GLint * " (parameter "first"))
      (paramdef "GLsizei * " (parameter "count"))
      (paramdef "GLsizei " (parameter "primcount"))))
  '(*fragment*
     (heading
       "render multiple sets of primitives from array data")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "mode")))
                   (para "
Specifies what kind of primitives to render.
                    Symbolic constants "
                         (code "GL_POINTS")
                         ", "
                         (code "GL_LINE_STRIP")
                         ", "
                         (code "GL_LINE_LOOP")
                         ", "
                         (code "GL_LINES")
                         ", "
                         (code "GL_TRIANGLE_STRIP")
                         ", "
                         (code "GL_TRIANGLE_FAN")
                         ", "
                         (code "GL_TRIANGLES")
                         ", "
                         (code "GL_QUAD_STRIP")
                         ", "
                         (code "GL_QUADS")
                         ",
                    and "
                         (code "GL_POLYGON")
                         " are accepted. "))
            (entry (% (heading (var "first")))
                   (para "
Points to an array of starting indices in the enabled arrays. "))
            (entry (% (heading (var "count")))
                   (para "
Points to an array of the number of indices to be rendered. "))
            (entry (% (heading (var "primcount")))
                   (para "
Specifies the size of the first and count ")))
     (heading "Description")
     (para (code "glMultiDrawArrays")
           " specifies multiple sets of geometric primitives
            with very few subroutine calls. Instead of calling a GL procedure
            to pass each individual vertex, normal, texture coordinate, edge
            flag, or color, you can prespecify
            separate arrays of vertices, normals, and colors and use them to
            construct a sequence of primitives with a single
            call to "
           (code "glMultiDrawArrays")
           ". ")
     (para (code "glMultiDrawArrays")
           " behaves identically to "
           (code "glDrawArrays")
           " except that "
           (var "primcount")
           "
separate ranges of elements are specified instead. ")
     (para "
When "
           (code "glMultiDrawArrays")
           " is called, it uses "
           (var "count")
           " sequential elements from each
            enabled array to construct a sequence of geometric primitives,
            beginning with element "
           (var "first")
           ". "
           (var "mode")
           " specifies what kind of
            primitives are constructed, and how the array elements
            construct those primitives. If "
           (code "GL_VERTEX_ARRAY")
           " is not enabled, no
            geometric primitives are generated. ")
     (para "
Vertex attributes that are modified by "
           (code "glMultiDrawArrays")
           " have an
            unspecified value after "
           (code "glMultiDrawArrays")
           " returns. For example, if "
           (code "GL_COLOR_ARRAY")
           " is enabled, the value of the current color is
            undefined after "
           (code "glMultiDrawArrays")
           " executes. Attributes that aren't
            modified remain well defined. ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "mode")
           " is not an accepted value. ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "primcount")
           " is negative. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to an
            enabled array and the buffer object's data store is currently mapped. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glMultiDrawArrays")
           " is executed between
            the execution of "
           (code "glBegin")
           " and the corresponding "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glMultiDrawElements
  "glMultiDrawElements"
  (funcsynopsis
    (funcprototype
      (funcdef
        "void "
        (function "glMultiDrawElements"))
      (paramdef "GLenum " (parameter "mode"))
      (paramdef "const GLsizei * " (parameter "count"))
      (paramdef "GLenum " (parameter "type"))
      (paramdef
        "const GLvoid ** "
        (parameter "indices"))
      (paramdef "GLsizei " (parameter "primcount"))))
  '(*fragment*
     (heading
       "render multiple sets of primitives by specifying indices of array data elements")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "mode")))
                   (para "
Specifies what kind of primitives to render.
                    Symbolic constants "
                         (code "GL_POINTS")
                         ", "
                         (code "GL_LINE_STRIP")
                         ", "
                         (code "GL_LINE_LOOP")
                         ", "
                         (code "GL_LINES")
                         ", "
                         (code "GL_TRIANGLE_STRIP")
                         ", "
                         (code "GL_TRIANGLE_FAN")
                         ", "
                         (code "GL_TRIANGLES")
                         ", "
                         (code "GL_QUAD_STRIP")
                         ", "
                         (code "GL_QUADS")
                         ",
                    and "
                         (code "GL_POLYGON")
                         " are accepted. "))
            (entry (% (heading (var "count")))
                   (para "
Points to an array of the elements counts. "))
            (entry (% (heading (var "type")))
                   (para "
Specifies the type of the values in "
                         (var "indices")
                         ". Must be one of "
                         (code "GL_UNSIGNED_BYTE")
                         ", "
                         (code "GL_UNSIGNED_SHORT")
                         ", or "
                         (code "GL_UNSIGNED_INT")
                         ". "))
            (entry (% (heading (var "indices")))
                   (para "
Specifies a pointer to the location where the indices are stored. "))
            (entry (% (heading (var "primcount")))
                   (para "
Specifies the size of the "
                         (var "count")
                         " array. ")))
     (heading "Description")
     (para (code "glMultiDrawElements")
           " specifies multiple sets of geometric primitives with very few subroutine
            calls. Instead of calling a GL function to pass each individual vertex,
            normal, texture coordinate, edge flag, or color, you can prespecify
            separate arrays of vertices, normals, and so on, and use them to construct a
            sequence of primitives with a single call to "
           (code "glMultiDrawElements")
           ". ")
     (para (code "glMultiDrawElements")
           " is identical in operation to "
           (code "glDrawElements")
           " except that "
           (var "primcount")
           " separate lists of elements are specified. ")
     (para "
Vertex attributes that are modified by "
           (code "glMultiDrawElements")
           " have an
            unspecified value after "
           (code "glMultiDrawElements")
           " returns. For example, if "
           (code "GL_COLOR_ARRAY")
           " is enabled, the value of the current color is
            undefined after "
           (code "glMultiDrawElements")
           " executes. Attributes that aren't
            modified maintain their previous values. ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "mode")
           " is not an accepted value. ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "primcount")
           " is negative. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to an
            enabled array or the element array and the buffer object's data store is currently mapped. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glMultiDrawElements")
           " is executed between
            the execution of "
           (code "glBegin")
           " and the corresponding "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glMultiTexCoord
  "glMultiTexCoord"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glMultiTexCoord1s"))
      (paramdef "GLenum " (parameter "target"))
      (paramdef "GLshort " (parameter "s"))))
  '(*fragment*
     (heading "set the current texture coordinates")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "target")))
                   (para "
Specifies the texture unit whose coordinates should be modified. The number
                    of texture units is implementation dependent, but must be at least
                    two. Symbolic constant must be one of "
                         (code "GL_TEXTURE")
                         (math (var "i"))
                         ",
                    where i ranges from 0 to "
                         (code "GL_MAX_TEXTURE_COORDS")
                         " - 1,
                    which is an implementation-dependent value. "))
            (entry (% (heading (var "s")))
                   (itemx (var "t"))
                   (itemx (var "r"))
                   (itemx (var "q"))
                   (para "
Specify "
                         (var "s")
                         ", "
                         (var "t")
                         ", "
                         (var "r")
                         ", and "
                         (var "q")
                         " texture coordinates for "
                         (var "target")
                         " texture unit. Not all parameters are present in all forms
                    of the command. ")))
     (heading "Description")
     (para (code "glMultiTexCoord")
           " specifies texture coordinates in one, two, three, or four
            dimensions. "
           (code "glMultiTexCoord1")
           " sets the current texture
            coordinates to "
           (math "(" (var "s") "," "0" "0" "1" ")")
           ";
            a call to "
           (code "glMultiTexCoord2")
           "
sets them to "
           (math "(" (var "s") "," (var "t") "0" "1" ")")
           ".
            Similarly, "
           (code "glMultiTexCoord3")
           " specifies the texture coordinates as "
           (math "("
                 (var "s")
                 ","
                 (var "t")
                 (var "r")
                 "1"
                 ")")
           ",
            and "
           (code "glMultiTexCoord4")
           "
defines all four components explicitly as "
           (math "("
                 (var "s")
                 ","
                 (var "t")
                 (var "r")
                 (var "q")
                 ")")
           ". ")
     (para "
The current texture coordinates are part of the data
            that is associated with each vertex and with the current
            raster position.
            Initially, the values for "
           (math "("
                 (var "s")
                 ","
                 (var "t")
                 (var "r")
                 (var "q")
                 ")")
           "
are "
           (math "(" "0" "," "0" "0" "1" ")")
           ". ")
     (para)))

(define-gl-procedure
  glMultMatrix
  "glMultMatrix"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glMultMatrixd"))
      (paramdef "const GLdouble * " (parameter "m"))))
  '(*fragment*
     (heading
       "multiply the current matrix with the specified matrix")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "m")))
                   (para "
Points to 16 consecutive values that are used as the elements of
                    a "
                         (math "4" "×" "4")
                         "
column-major matrix. ")))
     (heading "Description")
     (para (code "glMultMatrix")
           " multiplies the current matrix with the one specified using "
           (var "m")
           ", and
            replaces the current matrix with the product. ")
     (para "
The current matrix is determined by the current matrix mode (see "
           (code "glMatrixMode")
           "). It is either the projection matrix,
            modelview matrix,
            or the texture matrix. ")
     (heading "Errors")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glMultMatrix")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glMultTransposeMatrix
  "glMultTransposeMatrix"
  (funcsynopsis
    (funcprototype
      (funcdef
        "void "
        (function "glMultTransposeMatrixd"))
      (paramdef "const GLdouble * " (parameter "m"))))
  '(*fragment*
     (heading
       "multiply the current matrix with the specified row-major ordered matrix")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "m")))
                   (para "
Points to 16 consecutive values that are used as the elements of
                    a "
                         (math "4" "×" "4")
                         "
row-major matrix. ")))
     (heading "Description")
     (para (code "glMultTransposeMatrix")
           " multiplies the current matrix with the one specified using "
           (var "m")
           ", and
            replaces the current matrix with the product. ")
     (para "
The current matrix is determined by the current matrix mode (see "
           (code "glMatrixMode")
           "). It is either the projection matrix, modelview matrix,
            or the texture matrix. ")
     (heading "Errors")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glMultTransposeMatrix")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glNewList
  "glNewList"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glNewList"))
      (paramdef "GLuint " (parameter "list"))
      (paramdef "GLenum " (parameter "mode"))))
  '(*fragment*
     (heading "create or replace a display list")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "list")))
                   (para "
Specifies the display-list name. "))
            (entry (% (heading (var "mode")))
                   (para "
Specifies the compilation mode,
                    which can be "
                         (code "GL_COMPILE")
                         " or "
                         (code "GL_COMPILE_AND_EXECUTE")
                         ". ")))
     (heading "Description")
     (para "
Display lists are groups of GL commands that have been stored
            for subsequent execution.
            Display lists are created with "
           (code "glNewList")
           ".
            All subsequent commands are placed in the display list,
            in the order issued,
            until "
           (code "glEndList")
           " is called. ")
     (para (code "glNewList")
           " has two arguments.
            The first argument, "
           (var "list")
           ",
            is a positive integer that becomes the unique name for the display list.
            Names can be created and reserved with "
           (code "glGenLists")
           "
and tested for uniqueness with "
           (code "glIsList")
           ".
            The second argument, "
           (var "mode")
           ",
            is a symbolic constant that can assume one of two values: ")
     (table (% (formatter (asis)))
            (entry (% (heading (code "GL_COMPILE")))
                   (para "
Commands are merely compiled. "))
            (entry (% (heading (code "GL_COMPILE_AND_EXECUTE")))
                   (para "
Commands are executed as they are compiled into the display list. ")))
     (para "
Certain commands are not compiled into the display list
            but are executed immediately,
            regardless of the display-list mode.
            These commands are "
           (code "glAreTexturesResident")
           ", "
           (code "glColorPointer")
           ", "
           (code "glDeleteLists")
           ", "
           (code "glDeleteTextures")
           ", "
           (code "glDisableClientState")
           ", "
           (code "glEdgeFlagPointer")
           ", "
           (code "glEnableClientState")
           ", "
           (code "glFeedbackBuffer")
           ", "
           (code "glFinish")
           ", "
           (code "glFlush")
           ", "
           (code "glGenLists")
           ", "
           (code "glGenTextures")
           ", "
           (code "glIndexPointer")
           ", "
           (code "glInterleavedArrays")
           ", "
           (code "glIsEnabled")
           ", "
           (code "glIsList")
           ", "
           (code "glIsTexture")
           ", "
           (code "glNormalPointer")
           ", "
           (code "glPopClientAttrib")
           ", "
           (code "glPixelStore")
           ", "
           (code "glPushClientAttrib")
           ", "
           (code "glReadPixels")
           ", "
           (code "glRenderMode")
           ", "
           (code "glSelectBuffer")
           ", "
           (code "glTexCoordPointer")
           ", "
           (code "glVertexPointer")
           ",
            and all of the "
           (code "glGet")
           " commands. ")
     (para "
Similarly, "
           (code "glTexImage1D")
           ", "
           (code "glTexImage2D")
           ", and "
           (code "glTexImage3D")
           "
are executed immediately and not compiled into the display list when their
            first argument is "
           (code "GL_PROXY_TEXTURE_1D")
           ", "
           (code "GL_PROXY_TEXTURE_1D")
           ", or "
           (code "GL_PROXY_TEXTURE_3D")
           ", respectively. ")
     (para "
When the "
           (code "ARB_imaging")
           " extension is supported, "
           (code "glHistogram")
           " executes immediately when its argument is "
           (code "GL_PROXY_HISTOGRAM")
           ".  Similarly, "
           (code "glColorTable")
           " executes
            immediately when its first argument is "
           (code "GL_PROXY_COLOR_TABLE")
           ", "
           (code "GL_PROXY_POST_CONVOLUTION_COLOR_TABLE")
           ", or "
           (code "GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE")
           ". ")
     (para "
For OpenGL versions 1.3 and greater, or when the "
           (code "ARB_multitexture")
           " extension is supported, "
           (code "glClientActiveTexture")
           " is not compiled into display lists, but
            executed immediately. ")
     (para "
When "
           (code "glEndList")
           " is encountered,
            the display-list definition is completed by associating the list
            with the unique name "
           (var "list")
           "
(specified in the "
           (code "glNewList")
           " command).
            If a display list with name "
           (var "list")
           " already exists,
            it is replaced only when "
           (code "glEndList")
           " is called. ")
     (heading "Errors")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "list")
           " is 0. ")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "mode")
           " is not an accepted value. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glEndList")
           " is called
            without a preceding "
           (code "glNewList")
           ",
            or if "
           (code "glNewList")
           " is called while a display list is being defined. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glNewList")
           " or "
           (code "glEndList")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")
     (para (code "GL_OUT_OF_MEMORY")
           " is generated if there is insufficient memory to
            compile the display list. If the GL version is 1.1 or greater, no
            change is made to the previous contents of the display list, if any,
            and no other change is made to the GL state. (It is as if no attempt
            had been made to create the new display list.) ")))

(define-gl-procedure
  glNormalPointer
  "glNormalPointer"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glNormalPointer"))
      (paramdef "GLenum " (parameter "type"))
      (paramdef "GLsizei " (parameter "stride"))
      (paramdef
        "const GLvoid * "
        (parameter "pointer"))))
  '(*fragment*
     (heading "define an array of normals")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "type")))
                   (para "
Specifies the data type of each coordinate in the array.
                    Symbolic constants "
                         (code "GL_BYTE")
                         ", "
                         (code "GL_SHORT")
                         ", "
                         (code "GL_INT")
                         ", "
                         (code "GL_FLOAT")
                         ", and "
                         (code "GL_DOUBLE")
                         "
are accepted. The initial value is "
                         (code "GL_FLOAT")
                         ". "))
            (entry (% (heading (var "stride")))
                   (para "
Specifies the byte offset between consecutive normals. If "
                         (var "stride")
                         " is
                    0, the normals are understood to be tightly packed in
                    the array. The initial value is 0. "))
            (entry (% (heading (var "pointer")))
                   (para "
Specifies a pointer to the first coordinate of the first normal in the
                    array. The initial value is 0. ")))
     (heading "Description")
     (para (code "glNormalPointer")
           " specifies the location and data format of an array of normals
            to use when rendering. "
           (var "type")
           " specifies the data type of each normal coordinate,
            and "
           (var "stride")
           " specifies the byte stride from one
            normal to the next, allowing vertices and attributes
            to be packed into a single array or stored in separate arrays.
            (Single-array storage may be more efficient on some implementations;
            see "
           (code "glInterleavedArrays")
           ".) ")
     (para "
If a non-zero named buffer object is bound to the "
           (code "GL_ARRAY_BUFFER")
           " target 
            (see "
           (code "glBindBuffer")
           ") while a normal array is
            specified, "
           (var "pointer")
           " is treated as a byte offset into the buffer object's data store.
            Also, the buffer object binding ("
           (code "GL_ARRAY_BUFFER_BINDING")
           ") is saved as normal vertex array
            client-side state ("
           (code "GL_NORMAL_ARRAY_BUFFER_BINDING")
           "). ")
     (para "
When a normal array is specified, "
           (var "type")
           ", "
           (var "stride")
           ", and "
           (var "pointer")
           " are saved as client-side
            state, in addition to the current vertex array buffer object binding. ")
     (para "
To enable and disable the normal array, call "
           (code "glEnableClientState")
           " and "
           (code "glDisableClientState")
           " with the argument "
           (code "GL_NORMAL_ARRAY")
           ". If
            enabled, the normal array is used
            when "
           (code "glDrawArrays")
           ", "
           (code "glMultiDrawArrays")
           ", "
           (code "glDrawElements")
           ", "
           (code "glMultiDrawElements")
           ", "
           (code "glDrawRangeElements")
           ", or "
           (code "glArrayElement")
           " is called. ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "type")
           " is not an accepted value. ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "stride")
           " is negative. ")))

(define-gl-procedure
  glNormal
  "glNormal"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glNormal3b"))
      (paramdef "GLbyte " (parameter "nx"))
      (paramdef "GLbyte " (parameter "ny"))
      (paramdef "GLbyte " (parameter "nz"))))
  '(*fragment*
     (heading "set the current normal vector")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "nx")))
                   (itemx (var "ny"))
                   (itemx (var "nz"))
                   (para "
Specify the "
                         (math (var "x"))
                         ", "
                         (math (var "y"))
                         ",
                    and "
                         (math (var "z"))
                         "
coordinates of the new current normal.
                    The initial value of the current normal is the unit vector, (0, 0, 1). ")
                   (para)))
     (heading "Description")
     (para "
The current normal is set to the given coordinates
            whenever "
           (code "glNormal")
           " is issued.
            Byte, short, or integer arguments are converted to floating-point
            format with a linear mapping that maps the most positive representable integer
            value to 1.0
            and the most negative representable integer value to "
           (math "-1.0")
           ". ")
     (para "
Normals specified with "
           (code "glNormal")
           " need not have unit length.
            If "
           (code "GL_NORMALIZE")
           " is enabled,
            then normals of any length specified with "
           (code "glNormal")
           " are normalized after transformation.
            If "
           (code "GL_RESCALE_NORMAL")
           " is enabled, normals are scaled by a scaling factor
            derived from the modelview matrix. "
           (code "GL_RESCALE_NORMAL")
           " requires that the
            originally specified normals were of unit length, and that the modelview
            matrix contain only uniform scales for proper results.
            To enable and disable normalization, call "
           (code "glEnable")
           " and "
           (code "glDisable")
           "
with either "
           (code "GL_NORMALIZE")
           " or "
           (code "GL_RESCALE_NORMAL")
           ".
            Normalization is initially disabled. ")))

(define-gl-procedure
  glOrtho
  "glOrtho"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glOrtho"))
      (paramdef "GLdouble " (parameter "left"))
      (paramdef "GLdouble " (parameter "right"))
      (paramdef "GLdouble " (parameter "bottom"))
      (paramdef "GLdouble " (parameter "top"))
      (paramdef "GLdouble " (parameter "nearVal"))
      (paramdef "GLdouble " (parameter "farVal"))))
  '(*fragment*
     (heading
       "multiply the current matrix with an orthographic matrix")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "left")))
                   (itemx (var "right"))
                   (para "
Specify the coordinates for the left and right vertical clipping planes. "))
            (entry (% (heading (var "bottom")))
                   (itemx (var "top"))
                   (para "
Specify the coordinates for the bottom and top horizontal clipping planes. "))
            (entry (% (heading (var "nearVal")))
                   (itemx (var "farVal"))
                   (para "
Specify the distances to the nearer and farther depth clipping planes.
                    These values are negative if the plane is to be behind the viewer. ")))
     (heading "Description")
     (para (code "glOrtho")
           " describes a transformation that produces a parallel projection.
            The current matrix (see "
           (code "glMatrixMode")
           ") is multiplied by this matrix
            and the result replaces the current matrix, as if "
           (code "glMultMatrix")
           " were called with the following matrix
            as its argument: ")
     (para (math "("
                 "("
                 "2"
                 "/"
                 (var "right")
                 "-"
                 (var "left")
                 ","
                 ","
                 " "
                 "0"
                 " "
                 "0"
                 " "
                 (var "t")
                 "_"
                 (var "x")
                 ","
                 ")"
                 ", "
                 "("
                 "0"
                 " "
                 "2"
                 "/"
                 (var "top")
                 "-"
                 (var "bottom")
                 ","
                 ","
                 " "
                 "0"
                 " "
                 (var "t")
                 "_"
                 (var "y")
                 ","
                 ")"
                 ", "
                 "("
                 "0"
                 " "
                 "0"
                 " "
                 "-2"
                 "/"
                 (var "farVal")
                 "-"
                 (var "nearVal")
                 ","
                 ","
                 " "
                 (var "t")
                 "_"
                 (var "z")
                 ","
                 ")"
                 ", "
                 "("
                 "0"
                 " "
                 "0"
                 " "
                 "0"
                 " "
                 "1"
                 ")"
                 ","
                 ")"))
     (para "
where "
           (math (var "t")
                 "_"
                 (var "x")
                 "="
                 "-"
                 (var "right")
                 "+"
                 (var "left")
                 ","
                 "/"
                 (var "right")
                 "-"
                 (var "left")
                 ","
                 ",")
           (math (var "t")
                 "_"
                 (var "y")
                 "="
                 "-"
                 (var "top")
                 "+"
                 (var "bottom")
                 ","
                 "/"
                 (var "top")
                 "-"
                 (var "bottom")
                 ","
                 ",")
           (math (var "t")
                 "_"
                 (var "z")
                 "="
                 "-"
                 (var "farVal")
                 "+"
                 (var "nearVal")
                 ","
                 "/"
                 (var "farVal")
                 "-"
                 (var "nearVal")
                 ","
                 ","))
     (para "
Typically, the matrix mode is "
           (code "GL_PROJECTION")
           ", and "
           (math "("
                 (var "left")
                 ","
                 (var "bottom")
                 "-"
                 (var "nearVal")
                 ")")
           "
and "
           (math "("
                 (var "right")
                 ","
                 (var "top")
                 "-"
                 (var "nearVal")
                 ")")
           "
specify the points on the near clipping plane that are mapped
            to the lower left and upper right corners of the window,
            respectively,
            assuming that the eye is located at (0, 0, 0). "
           (math "-" (var "farVal"))
           "
specifies the location of the far clipping plane.
            Both "
           (var "nearVal")
           " and "
           (var "farVal")
           " can be either positive or negative. ")
     (para "
Use "
           (code "glPushMatrix")
           " and "
           (code "glPopMatrix")
           " to save and restore
            the current matrix stack. ")
     (heading "Errors")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "left")
           " = "
           (var "right")
           ", or "
           (var "bottom")
           " = "
           (var "top")
           ", or "
           (var "near")
           " = "
           (var "far")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glOrtho")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glPassThrough
  "glPassThrough"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glPassThrough"))
      (paramdef "GLfloat " (parameter "token"))))
  '(*fragment*
     (heading "place a marker in the feedback buffer")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "token")))
                   (para "
Specifies a marker value to be placed in the feedback buffer
                    following a "
                         (code "GL_PASS_THROUGH_TOKEN")
                         ". ")))
     (heading "Description")
     (para)
     (para "
Feedback is a GL render mode.
            The mode is selected by calling "
           (code "glRenderMode")
           " with "
           (code "GL_FEEDBACK")
           ".
            When the GL is in feedback mode,
            no pixels are produced by rasterization.
            Instead,
            information about primitives that would have been rasterized
            is fed back to the application using the GL.
            See the "
           (code "glFeedbackBuffer")
           " reference page for a description of the
            feedback buffer and the values in it. ")
     (para (code "glPassThrough")
           " inserts a user-defined marker in the feedback buffer
            when it is executed in feedback mode. "
           (var "token")
           " is returned as if it were a primitive;
            it is indicated with its own unique identifying value: "
           (code "GL_PASS_THROUGH_TOKEN")
           ".
            The order of "
           (code "glPassThrough")
           " commands with respect to the specification
            of graphics primitives is maintained. ")
     (heading "Errors")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glPassThrough")
           " is executed between
            the execution of "
           (code "glBegin")
           " and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glPixelMap
  "glPixelMap"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glPixelMapfv"))
      (paramdef "GLenum " (parameter "map"))
      (paramdef "GLsizei " (parameter "mapsize"))
      (paramdef
        "const GLfloat * "
        (parameter "values"))))
  '(*fragment*
     (heading "set up pixel transfer maps")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "map")))
                   (para "
Specifies a symbolic map name.
                    Must be one of the following: "
                         (code "GL_PIXEL_MAP_I_TO_I")
                         ", "
                         (code "GL_PIXEL_MAP_S_TO_S")
                         ", "
                         (code "GL_PIXEL_MAP_I_TO_R")
                         ", "
                         (code "GL_PIXEL_MAP_I_TO_G")
                         ", "
                         (code "GL_PIXEL_MAP_I_TO_B")
                         ", "
                         (code "GL_PIXEL_MAP_I_TO_A")
                         ", "
                         (code "GL_PIXEL_MAP_R_TO_R")
                         ", "
                         (code "GL_PIXEL_MAP_G_TO_G")
                         ", "
                         (code "GL_PIXEL_MAP_B_TO_B")
                         ", or "
                         (code "GL_PIXEL_MAP_A_TO_A")
                         ". "))
            (entry (% (heading (var "mapsize")))
                   (para "
Specifies the size of the map being defined. "))
            (entry (% (heading (var "values")))
                   (para "
Specifies an array of "
                         (var "mapsize")
                         " values. ")))
     (heading "Description")
     (para (code "glPixelMap")
           " sets up translation tables,
            or "
           (var "maps")
           ",
            used by "
           (code "glCopyPixels")
           ", "
           (code "glCopyTexImage1D")
           ", "
           (code "glCopyTexImage2D")
           ", "
           (code "glCopyTexSubImage1D")
           ", "
           (code "glCopyTexSubImage2D")
           ", "
           (code "glCopyTexSubImage3D")
           ", "
           (code "glDrawPixels")
           ", "
           (code "glReadPixels")
           ", "
           (code "glTexImage1D")
           ", "
           (code "glTexImage2D")
           ", "
           (code "glTexImage3D")
           ", "
           (code "glTexSubImage1D")
           ", "
           (code "glTexSubImage2D")
           ", and "
           (code "glTexSubImage3D")
           ".
            Additionally, if the "
           (code "ARB_imaging")
           " subset is supported, the
            routines "
           (code "glColorTable")
           ", "
           (code "glColorSubTable")
           ", "
           (code "glConvolutionFilter1D")
           ", "
           (code "glConvolutionFilter2D")
           ", "
           (code "glHistogram")
           ", "
           (code "glMinmax")
           ", and "
           (code "glSeparableFilter2D")
           ".
            Use of these maps is described completely in the "
           (code "glPixelTransfer")
           " reference page,
            and partly in the reference pages for the pixel and texture image commands.
            Only the specification of the maps is described in this reference page. ")
     (para (var "map")
           " is a symbolic map name,
            indicating one of ten maps to set. "
           (var "mapsize")
           " specifies the number of entries in the map,
            and "
           (var "values")
           " is a pointer to an array of "
           (var "mapsize")
           " map values. ")
     (para "
If a non-zero named buffer object is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target 
            (see "
           (code "glBindBuffer")
           ") while a pixel transfer map is
            specified, "
           (var "values")
           " is treated as a byte offset into the buffer object's data store. ")
     (para "
The ten maps are as follows: ")
     (table (% (formatter (asis)))
            (entry (% (heading (code "GL_PIXEL_MAP_I_TO_I")))
                   (para "
Maps color indices to color indices. "))
            (entry (% (heading (code "GL_PIXEL_MAP_S_TO_S")))
                   (para "
Maps stencil indices to stencil indices. "))
            (entry (% (heading (code "GL_PIXEL_MAP_I_TO_R")))
                   (para "
Maps color indices to red components. "))
            (entry (% (heading (code "GL_PIXEL_MAP_I_TO_G")))
                   (para "
Maps color indices to green components. "))
            (entry (% (heading (code "GL_PIXEL_MAP_I_TO_B")))
                   (para "
Maps color indices to blue components. "))
            (entry (% (heading (code "GL_PIXEL_MAP_I_TO_A")))
                   (para "
Maps color indices to alpha components. "))
            (entry (% (heading (code "GL_PIXEL_MAP_R_TO_R")))
                   (para "
Maps red components to red components. "))
            (entry (% (heading (code "GL_PIXEL_MAP_G_TO_G")))
                   (para "
Maps green components to green components. "))
            (entry (% (heading (code "GL_PIXEL_MAP_B_TO_B")))
                   (para "
Maps blue components to blue components. "))
            (entry (% (heading (code "GL_PIXEL_MAP_A_TO_A")))
                   (para "
Maps alpha components to alpha components. ")))
     (para "
The entries in a map can be specified as single-precision
            floating-point numbers,
            unsigned short integers,
            or unsigned int integers.
            Maps that store color component values
            (all but "
           (code "GL_PIXEL_MAP_I_TO_I")
           " and "
           (code "GL_PIXEL_MAP_S_TO_S")
           ")
            retain their values in floating-point format,
            with unspecified mantissa and exponent sizes.
            Floating-point values specified by "
           (code "glPixelMapfv")
           " are converted directly
            to the internal floating-point format of these maps,
            then clamped to the range [0,1].
            Unsigned integer values specified by "
           (code "glPixelMapusv")
           " and "
           (code "glPixelMapuiv")
           " are converted linearly such that
            the largest representable integer maps to 1.0,
            and 0 maps to 0.0. ")
     (para "
Maps that store indices, "
           (code "GL_PIXEL_MAP_I_TO_I")
           " and "
           (code "GL_PIXEL_MAP_S_TO_S")
           ",
            retain their values in fixed-point format,
            with an unspecified number of bits to the right of the binary point.
            Floating-point values specified by "
           (code "glPixelMapfv")
           " are converted directly
            to the internal fixed-point format of these maps.
            Unsigned integer values specified by "
           (code "glPixelMapusv")
           " and "
           (code "glPixelMapuiv")
           " specify integer values,
            with all 0's to the right of the binary point. ")
     (para "
The following table shows the initial sizes and values for each of the maps.
            Maps that are indexed by either color or stencil indices must have "
           (var "mapsize")
           " = "
           (math "2" "^" (var "n"))
           "
for some "
           (math (var "n"))
           "
or the results are undefined.
            The maximum allowable size for each map depends on the implementation
            and can be determined by calling "
           (code "glGet")
           " with argument "
           (code "GL_MAX_PIXEL_MAP_TABLE")
           ".
            The single maximum applies to all maps; it is at
            least 32. ")
     (table (% (formatter (asis)))
            (entry (% (heading (strong (var "map"))))
                   (para (strong "Lookup Index")
                         ", "
                         (strong "Lookup Value")
                         ", "
                         (strong "Initial Size")
                         ", "
                         (strong "Initial Value")))
            (entry (% (heading (code "GL_PIXEL_MAP_I_TO_I")))
                   (para "
color index "
                         ", "
                         "
color index "
                         ", "
                         "
1 "
                         ", "
                         "
0 "))
            (entry (% (heading (code "GL_PIXEL_MAP_S_TO_S")))
                   (para "
stencil index "
                         ", "
                         "
stencil index "
                         ", "
                         "
1 "
                         ", "
                         "
0 "))
            (entry (% (heading (code "GL_PIXEL_MAP_I_TO_R")))
                   (para "
color index "
                         ", "
                         "
R "
                         ", "
                         "
1 "
                         ", "
                         "
0 "))
            (entry (% (heading (code "GL_PIXEL_MAP_I_TO_G")))
                   (para "
color index "
                         ", "
                         "
G "
                         ", "
                         "
1 "
                         ", "
                         "
0 "))
            (entry (% (heading (code "GL_PIXEL_MAP_I_TO_B")))
                   (para "
color index "
                         ", "
                         "
B "
                         ", "
                         "
1 "
                         ", "
                         "
0 "))
            (entry (% (heading (code "GL_PIXEL_MAP_I_TO_A")))
                   (para "
color index "
                         ", "
                         "
A "
                         ", "
                         "
1 "
                         ", "
                         "
0 "))
            (entry (% (heading (code "GL_PIXEL_MAP_R_TO_R")))
                   (para "
R " ", " "
R " ", " "
1 " ", " "
0 "))
            (entry (% (heading (code "GL_PIXEL_MAP_G_TO_G")))
                   (para "
G " ", " "
G " ", " "
1 " ", " "
0 "))
            (entry (% (heading (code "GL_PIXEL_MAP_B_TO_B")))
                   (para "
B " ", " "
B " ", " "
1 " ", " "
0 "))
            (entry (% (heading (code "GL_PIXEL_MAP_A_TO_A")))
                   (para "
A " ", " "
A " ", " "
1 " ", " "
0 ")))
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "map")
           " is not an accepted value. ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "mapsize")
           " is less than one
            or larger than "
           (code "GL_MAX_PIXEL_MAP_TABLE")
           ". ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "map")
           " is "
           (code "GL_PIXEL_MAP_I_TO_I")
           ", "
           (code "GL_PIXEL_MAP_S_TO_S")
           ", "
           (code "GL_PIXEL_MAP_I_TO_R")
           ", "
           (code "GL_PIXEL_MAP_I_TO_G")
           ", "
           (code "GL_PIXEL_MAP_I_TO_B")
           ", or "
           (code "GL_PIXEL_MAP_I_TO_A")
           ",
            and "
           (var "mapsize")
           " is not a power of two. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target and the buffer object's data store is currently mapped. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target and the data would be unpacked from the buffer 
            object such that the memory reads required would exceed the data store size. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated by "
           (code "glPixelMapfv")
           " if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target and "
           (var "values")
           " is not evenly divisible 
            into the number of bytes needed to store in memory a GLfloat datum. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated by "
           (code "glPixelMapuiv")
           " if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target and "
           (var "values")
           " is not evenly divisible 
            into the number of bytes needed to store in memory a GLuint datum. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated by "
           (code "glPixelMapusv")
           " if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target and "
           (var "values")
           " is not evenly divisible 
            into the number of bytes needed to store in memory a GLushort datum. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glPixelMap")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glPixelStore
  "glPixelStore"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glPixelStoref"))
      (paramdef "GLenum " (parameter "pname"))
      (paramdef "GLfloat " (parameter "param"))))
  '(*fragment*
     (heading "set pixel storage modes")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "pname")))
                   (para "
Specifies the symbolic name of the parameter to be set.
                    Six values affect the packing of pixel data into memory: "
                         (code "GL_PACK_SWAP_BYTES")
                         ", "
                         (code "GL_PACK_LSB_FIRST")
                         ", "
                         (code "GL_PACK_ROW_LENGTH")
                         ", "
                         (code "GL_PACK_IMAGE_HEIGHT")
                         ", "
                         (code "GL_PACK_SKIP_PIXELS")
                         ", "
                         (code "GL_PACK_SKIP_ROWS")
                         ", "
                         (code "GL_PACK_SKIP_IMAGES")
                         ", and "
                         (code "GL_PACK_ALIGNMENT")
                         ".
                    Six more affect the unpacking of pixel data "
                         (var "from")
                         " memory: "
                         (code "GL_UNPACK_SWAP_BYTES")
                         ", "
                         (code "GL_UNPACK_LSB_FIRST")
                         ", "
                         (code "GL_UNPACK_ROW_LENGTH")
                         ", "
                         (code "GL_UNPACK_IMAGE_HEIGHT")
                         ", "
                         (code "GL_UNPACK_SKIP_PIXELS")
                         ", "
                         (code "GL_UNPACK_SKIP_ROWS")
                         ", "
                         (code "GL_UNPACK_SKIP_IMAGES")
                         ", and "
                         (code "GL_UNPACK_ALIGNMENT")
                         ". "))
            (entry (% (heading (var "param")))
                   (para "
Specifies the value that "
                         (var "pname")
                         " is set to. ")))
     (heading "Description")
     (para (code "glPixelStore")
           " sets pixel storage modes that affect the operation of subsequent "
           (code "glDrawPixels")
           " and "
           (code "glReadPixels")
           " as well as the unpacking of
            polygon stipple patterns (see "
           (code "glPolygonStipple")
           "), bitmaps (see "
           (code "glBitmap")
           "), texture patterns (see "
           (code "glTexImage1D")
           ", "
           (code "glTexImage2D")
           ", "
           (code "glTexImage3D")
           ", "
           (code "glTexSubImage1D")
           ", "
           (code "glTexSubImage2D")
           ", "
           (code "glTexSubImage3D")
           ").
            Additionally, if the "
           (code "ARB_imaging")
           " extension is supported, pixel
            storage modes affect convolution filters
            (see "
           (code "glConvolutionFilter1D")
           ", "
           (code "glConvolutionFilter2D")
           ", and "
           (code "glSeparableFilter2D")
           ", color table (see "
           (code "glColorTable")
           ", and "
           (code "glColorSubTable")
           ", and unpacking histogram (See "
           (code "glHistogram")
           "),
            and minmax (See "
           (code "glMinmax")
           ") data. ")
     (para (var "pname")
           " is a symbolic constant indicating the parameter to be set, and "
           (var "param")
           " is the new value.  Six of the twelve storage parameters affect
            how pixel data is returned to client memory.
            They are as follows: ")
     (table (% (formatter (asis)))
            (entry (% (heading (code "GL_PACK_SWAP_BYTES")))
                   (para "
If true,
                        byte ordering for multibyte color components,
                        depth components,
                        color indices,
                        or stencil indices
                        is reversed.
                        That is,
                        if a four-byte component consists of bytes "
                         (math (var "b") "_" "0")
                         ", "
                         (math (var "b") "_" "1")
                         ", "
                         (math (var "b") "_" "2")
                         ", "
                         (math (var "b") "_" "3")
                         ",
                        it is stored in memory as "
                         (math (var "b") "_" "3")
                         ", "
                         (math (var "b") "_" "2")
                         ", "
                         (math (var "b") "_" "1")
                         ", "
                         (math (var "b") "_" "0")
                         "
if "
                         (code "GL_PACK_SWAP_BYTES")
                         " is true. "
                         (code "GL_PACK_SWAP_BYTES")
                         " has no effect on the memory order of components
                        within a pixel,
                        only on the order of bytes within components or indices.
                        For example,
                        the three components of a "
                         (code "GL_RGB")
                         " format pixel are always stored with
                        red first,
                        green second,
                        and blue third,
                        regardless of the value of "
                         (code "GL_PACK_SWAP_BYTES")
                         ". "))
            (entry (% (heading (code "GL_PACK_LSB_FIRST")))
                   (para "
If true,
                        bits are ordered within a byte from least significant to most significant;
                        otherwise,
                        the first bit in each byte is the most significant one.
                        This parameter is significant for bitmap data only. "))
            (entry (% (heading (code "GL_PACK_ROW_LENGTH")))
                   (para "
If greater than 0, "
                         (code "GL_PACK_ROW_LENGTH")
                         " defines the number of pixels in a row.
                        If the first pixel of a row is placed at location "
                         (math (var "p"))
                         "
in memory,
                        then the location of the first pixel of the next row is obtained by skipping ")
                   (para (math (var "k")
                               "="
                               "{"
                               "("
                               (var "n")
                               "\u2062"
                               (var "l")
                               ")"
                               ", "
                               "("
                               (var "a")
                               "/"
                               (var "s")
                               ","
                               "\u2062"
                               "⌈"
                               (var "s")
                               "\u2062"
                               (var "n")
                               "\u2062"
                               (var "l")
                               ","
                               "/"
                               (var "a")
                               ","
                               "⌉"
                               ")"
                               "\u2062"
                               "("
                               (var "s")
                               ">="
                               (var "a")
                               ")"
                               ", "
                               "("
                               (var "s")
                               "<"
                               (var "a")
                               ")"
                               ","))
                   (para "
components or indices,
                        where "
                         (math (var "n"))
                         "
is the number of components or indices in a pixel, "
                         (math (var "l"))
                         "
is the number of pixels in a row
                        ("
                         (code "GL_PACK_ROW_LENGTH")
                         " if it is greater than 0,
                        the "
                         (math (var "width"))
                         "
argument to the pixel routine otherwise), "
                         (math (var "a"))
                         "
is the value of "
                         (code "GL_PACK_ALIGNMENT")
                         ", and "
                         (math (var "s"))
                         "
is the size, in bytes, of a single component
                        (if "
                         (math (var "a") "<" (var "s"))
                         ",
                        then it is as if "
                         (math (var "a") "=" (var "s"))
                         ").
                        In the case of 1-bit values,
                        the location of the next row is obtained by skipping ")
                   (para (math (var "k")
                               "="
                               "8"
                               "\u2062"
                               (var "a")
                               "\u2062"
                               "⌈"
                               (var "n")
                               "\u2062"
                               (var "l")
                               ","
                               "/"
                               "8"
                               "\u2062"
                               (var "a")
                               ","
                               ","
                               "⌉"))
                   (para "
components or indices. ")
                   (para "
The word "
                         (var "component")
                         " in this description refers to the nonindex values
                        red,
                        green,
                        blue,
                        alpha,
                        and depth.
                        Storage format "
                         (code "GL_RGB")
                         ",
                        for example,
                        has three components per pixel:
                        first red,
                        then green,
                        and finally blue. "))
            (entry (% (heading (code "GL_PACK_IMAGE_HEIGHT")))
                   (para "
If greater than 0, "
                         (code "GL_PACK_IMAGE_HEIGHT")
                         " defines the number of pixels in an image
                        three-dimensional texture volume, where ``image'' is defined by all pixels
                        sharing the same third dimension index.
                        If the first pixel of a row is placed at location "
                         (math (var "p"))
                         "
in memory,
                        then the location of the first pixel of the next row is obtained by skipping ")
                   (para (math (var "k")
                               "="
                               "{"
                               "("
                               (var "n")
                               "\u2062"
                               (var "l")
                               "\u2062"
                               (var "h")
                               ")"
                               ", "
                               "("
                               (var "a")
                               "/"
                               (var "s")
                               ","
                               "\u2062"
                               "⌈"
                               (var "s")
                               "\u2062"
                               (var "n")
                               "\u2062"
                               (var "l")
                               "\u2062"
                               (var "h")
                               ","
                               "/"
                               (var "a")
                               ","
                               "⌉"
                               ")"
                               "\u2062"
                               "("
                               (var "s")
                               ">="
                               (var "a")
                               ")"
                               ", "
                               "("
                               (var "s")
                               "<"
                               (var "a")
                               ")"
                               ","))
                   (para "
components or indices, where "
                         (math (var "n"))
                         "
is the number of components or indices
                        in a pixel, "
                         (math (var "l"))
                         "
is the number of pixels in a row
                        ("
                         (code "GL_PACK_ROW_LENGTH")
                         " if it is greater than 0, the "
                         (math (var "width"))
                         "
argument to "
                         (code "glTexImage3D")
                         " otherwise), "
                         (math (var "h"))
                         "
is the number of
                        rows in a pixel image ("
                         (code "GL_PACK_IMAGE_HEIGHT")
                         " if it is greater than
                        0, the "
                         (math (var "height"))
                         "
argument to the "
                         (code "glTexImage3D")
                         " routine otherwise), "
                         (math (var "a"))
                         "
is the value of "
                         (code "GL_PACK_ALIGNMENT")
                         ", and "
                         (math (var "s"))
                         "
is the size, in bytes, of a single
                        component (if "
                         (math (var "a") "<" (var "s"))
                         ",
                        then it is as if "
                         (math (var "a") "=" (var "s"))
                         "). ")
                   (para "
The word "
                         (var "component")
                         " in this description refers to the nonindex values
                        red,
                        green,
                        blue,
                        alpha,
                        and depth.
                        Storage format "
                         (code "GL_RGB")
                         ",
                        for example,
                        has three components per pixel:
                        first red,
                        then green,
                        and finally blue. "))
            (entry (% (heading
                        (code "GL_PACK_SKIP_PIXELS")
                        ", "
                        (code "GL_PACK_SKIP_ROWS")
                        ", and "
                        (code "GL_PACK_SKIP_IMAGES")))
                   (para "
These values are provided as a convenience to the programmer;
                        they provide no functionality that cannot be duplicated simply by
                        incrementing the pointer passed to "
                         (code "glReadPixels")
                         ".
                        Setting "
                         (code "GL_PACK_SKIP_PIXELS")
                         " to "
                         (math (var "i"))
                         "
is equivalent to incrementing
                        the pointer by "
                         (math (var "i") "\u2062" (var "n"))
                         "
components or indices,
                        where "
                         (math (var "n"))
                         "
is the number of components or indices in each pixel.
                        Setting "
                         (code "GL_PACK_SKIP_ROWS")
                         " to "
                         (math (var "j"))
                         "
is equivalent to incrementing
                        the pointer by "
                         (math (var "j") "\u2062" (var "m"))
                         "
components or indices,
                        where "
                         (math (var "m"))
                         "
is the number of components or indices per row,
                        as just computed in the "
                         (code "GL_PACK_ROW_LENGTH")
                         " section.
                        Setting "
                         (code "GL_PACK_SKIP_IMAGES")
                         " to "
                         (math (var "k"))
                         "
is equivalent to incrementing
                        the pointer by "
                         (math (var "k") "\u2062" (var "p"))
                         ",
                        where "
                         (math (var "p"))
                         "
is the number of components or indices
                        per image, as computed in the "
                         (code "GL_PACK_IMAGE_HEIGHT")
                         " section. "))
            (entry (% (heading (code "GL_PACK_ALIGNMENT")))
                   (para "
Specifies the alignment requirements for the start of each pixel row in memory.
                        The allowable values are
                        1 (byte-alignment),
                        2 (rows aligned to even-numbered bytes),
                        4 (word-alignment), and
                        8 (rows start on double-word boundaries). ")))
     (para "
The other six of the twelve storage parameters affect how pixel data is
            read from client memory.
            These values are significant for "
           (code "glDrawPixels")
           ", "
           (code "glTexImage1D")
           ", "
           (code "glTexImage2D")
           ", "
           (code "glTexImage3D")
           ", "
           (code "glTexSubImage1D")
           ", "
           (code "glTexSubImage2D")
           ", "
           (code "glTexSubImage3D")
           ", "
           (code "glBitmap")
           ", and "
           (code "glPolygonStipple")
           ". ")
     (para "
Additionally, if the "
           (code "ARB_imaging")
           " extension is supported, "
           (code "glColorTable")
           ", "
           (code "glColorSubTable")
           ", "
           (code "glConvolutionFilter1D")
           ", "
           (code "glConvolutionFilter2D")
           ", and "
           (code "glSeparableFilter2D")
           ".
            They are as follows: ")
     (table (% (formatter (asis)))
            (entry (% (heading (code "GL_UNPACK_SWAP_BYTES")))
                   (para "
If true,
                        byte ordering for multibyte color components,
                        depth components,
                        color indices,
                        or stencil indices
                        is reversed.
                        That is,
                        if a four-byte component consists of bytes "
                         (math (var "b") "_" "0")
                         ", "
                         (math (var "b") "_" "1")
                         ", "
                         (math (var "b") "_" "2")
                         ", "
                         (math (var "b") "_" "3")
                         ",
                        it is taken from memory as "
                         (math (var "b") "_" "3")
                         ", "
                         (math (var "b") "_" "2")
                         ", "
                         (math (var "b") "_" "1")
                         ", "
                         (math (var "b") "_" "0")
                         "
if "
                         (code "GL_UNPACK_SWAP_BYTES")
                         " is true. "
                         (code "GL_UNPACK_SWAP_BYTES")
                         " has no effect on the memory order of components
                        within a pixel,
                        only on the order of bytes within components or indices.
                        For example,
                        the three components of a "
                         (code "GL_RGB")
                         " format pixel are always stored with
                        red first,
                        green second,
                        and blue third,
                        regardless of the value of "
                         (code "GL_UNPACK_SWAP_BYTES")
                         ". "))
            (entry (% (heading (code "GL_UNPACK_LSB_FIRST")))
                   (para "
If true,
                        bits are ordered within a byte from least significant to most significant;
                        otherwise,
                        the first bit in each byte is the most significant one.
                        This is relevant only for bitmap data. "))
            (entry (% (heading (code "GL_UNPACK_ROW_LENGTH")))
                   (para "
If greater than 0, "
                         (code "GL_UNPACK_ROW_LENGTH")
                         " defines the number of pixels in a row.
                        If the first pixel of a row is placed at location "
                         (math (var "p"))
                         "
in memory,
                        then the location of the first pixel of the next row is obtained by skipping ")
                   (para (math (var "k")
                               "="
                               "{"
                               "("
                               (var "n")
                               "\u2062"
                               (var "l")
                               ")"
                               ", "
                               "("
                               (var "a")
                               "/"
                               (var "s")
                               ","
                               "\u2062"
                               "⌈"
                               (var "s")
                               "\u2062"
                               (var "n")
                               "\u2062"
                               (var "l")
                               ","
                               "/"
                               (var "a")
                               ","
                               "⌉"
                               ")"
                               "\u2062"
                               "("
                               (var "s")
                               ">="
                               (var "a")
                               ")"
                               ", "
                               "("
                               (var "s")
                               "<"
                               (var "a")
                               ")"
                               ","))
                   (para "
components or indices,
                        where "
                         (math (var "n"))
                         "
is the number of components or indices in a pixel, "
                         (math (var "l"))
                         "
is the number of pixels in a row
                        ("
                         (code "GL_UNPACK_ROW_LENGTH")
                         " if it is greater than 0,
                        the "
                         (math (var "width"))
                         "
argument to the pixel routine otherwise), "
                         (math (var "a"))
                         "
is the value of "
                         (code "GL_UNPACK_ALIGNMENT")
                         ", and "
                         (math (var "s"))
                         "
is the size, in bytes, of a single component
                        (if "
                         (math (var "a") "<" (var "s"))
                         ",
                        then it is as if "
                         (math (var "a") "=" (var "s"))
                         ").
                        In the case of 1-bit values,
                        the location of the next row is obtained by skipping ")
                   (para (math (var "k")
                               "="
                               "8"
                               "\u2062"
                               (var "a")
                               "\u2062"
                               "⌈"
                               (var "n")
                               "\u2062"
                               (var "l")
                               ","
                               "/"
                               "8"
                               "\u2062"
                               (var "a")
                               ","
                               ","
                               "⌉"))
                   (para "
components or indices. ")
                   (para "
The word "
                         (var "component")
                         " in this description refers to the nonindex values
                        red,
                        green,
                        blue,
                        alpha,
                        and depth.
                        Storage format "
                         (code "GL_RGB")
                         ",
                        for example,
                        has three components per pixel:
                        first red,
                        then green,
                        and finally blue. "))
            (entry (% (heading (code "GL_UNPACK_IMAGE_HEIGHT")))
                   (para "
If greater than 0, "
                         (code "GL_UNPACK_IMAGE_HEIGHT")
                         " defines the number of pixels in an image of
                        a three-dimensional texture volume.  Where ``image'' is defined by all
                        pixel sharing the same third dimension index.
                        If the first pixel of a row is placed at location "
                         (math (var "p"))
                         "
in memory,
                        then the location of the first pixel of the next row is obtained by skipping ")
                   (para (math (var "k")
                               "="
                               "{"
                               "("
                               (var "n")
                               "\u2062"
                               (var "l")
                               "\u2062"
                               (var "h")
                               ")"
                               ", "
                               "("
                               (var "a")
                               "/"
                               (var "s")
                               ","
                               "\u2062"
                               "⌈"
                               (var "s")
                               "\u2062"
                               (var "n")
                               "\u2062"
                               (var "l")
                               "\u2062"
                               (var "h")
                               ","
                               "/"
                               (var "a")
                               ","
                               "⌉"
                               ")"
                               "\u2062"
                               "("
                               (var "s")
                               ">="
                               (var "a")
                               ")"
                               ", "
                               "("
                               (var "s")
                               "<"
                               (var "a")
                               ")"
                               ","))
                   (para "
components or indices,
                        where "
                         (math (var "n"))
                         "
is the number of components or indices in a pixel, "
                         (math (var "l"))
                         "
is the number of pixels in a row
                        ("
                         (code "GL_UNPACK_ROW_LENGTH")
                         " if it is greater than 0,
                        the "
                         (math (var "width"))
                         "
argument to "
                         (code "glTexImage3D")
                         " otherwise), "
                         (math (var "h"))
                         "
is the number of rows in an image ("
                         (code "GL_UNPACK_IMAGE_HEIGHT")
                         " if
                        it is greater than 0, the "
                         (math (var "height"))
                         "
argument to "
                         (code "glTexImage3D")
                         " otherwise), "
                         (math (var "a"))
                         "
is the value of "
                         (code "GL_UNPACK_ALIGNMENT")
                         ", and "
                         (math (var "s"))
                         "
is the size, in bytes, of a single component
                        (if "
                         (math (var "a") "<" (var "s"))
                         ",
                        then it is as if "
                         (math (var "a") "=" (var "s"))
                         "). ")
                   (para "
The word "
                         (var "component")
                         " in this description refers to the nonindex values
                        red,
                        green,
                        blue,
                        alpha,
                        and depth.
                        Storage format "
                         (code "GL_RGB")
                         ",
                        for example,
                        has three components per pixel:
                        first red,
                        then green,
                        and finally blue. "))
            (entry (% (heading
                        (code "GL_UNPACK_SKIP_PIXELS")
                        " and "
                        (code "GL_UNPACK_SKIP_ROWS")))
                   (para "
These values are provided as a convenience to the programmer;
                        they provide no functionality that cannot be duplicated by
                        incrementing the pointer passed to "
                         (code "glDrawPixels")
                         ", "
                         (code "glTexImage1D")
                         ", "
                         (code "glTexImage2D")
                         ", "
                         (code "glTexSubImage1D")
                         ", "
                         (code "glTexSubImage2D")
                         ", "
                         (code "glBitmap")
                         ", or "
                         (code "glPolygonStipple")
                         ".
                        Setting "
                         (code "GL_UNPACK_SKIP_PIXELS")
                         " to "
                         (math (var "i"))
                         "
is equivalent to incrementing
                        the pointer by "
                         (math (var "i") "\u2062" (var "n"))
                         "
components or indices,
                        where "
                         (math (var "n"))
                         "
is the number of components or indices in each pixel.
                        Setting "
                         (code "GL_UNPACK_SKIP_ROWS")
                         " to "
                         (math (var "j"))
                         "
is equivalent to incrementing
                        the pointer by "
                         (math (var "j") "\u2062" (var "k"))
                         "
components or indices,
                        where "
                         (math (var "k"))
                         "
is the number of components or indices per row,
                        as just computed in the "
                         (code "GL_UNPACK_ROW_LENGTH")
                         " section. "))
            (entry (% (heading (code "GL_UNPACK_ALIGNMENT")))
                   (para "
Specifies the alignment requirements for the start of each pixel row in memory.
                        The allowable values are
                        1 (byte-alignment),
                        2 (rows aligned to even-numbered bytes),
                        4 (word-alignment), and
                        8 (rows start on double-word boundaries). ")))
     (para "
The following table gives the type,
            initial value,
            and range of valid values for each storage parameter
            that can be set with "
           (code "glPixelStore")
           ". ")
     (para)
     (table (% (formatter (asis)))
            (entry (% (heading (strong (var "pname"))))
                   (para (strong "Type")
                         ", "
                         (strong "Initial Value")
                         ", "
                         (strong "Valid Range")))
            (entry (% (heading (code "GL_PACK_SWAP_BYTES")))
                   (para "
boolean "
                         ", "
                         "
false "
                         ", "
                         "
true or false "))
            (entry (% (heading (code "GL_PACK_LSB_FIRST")))
                   (para "
boolean "
                         ", "
                         "
false "
                         ", "
                         "
true or false "))
            (entry (% (heading (code "GL_PACK_ROW_LENGTH")))
                   (para "
integer "
                         ", "
                         "
0 "
                         ", "
                         (math "[" "0" "," "∞" ")")))
            (entry (% (heading (code "GL_PACK_IMAGE_HEIGHT")))
                   (para "
integer "
                         ", "
                         "
0 "
                         ", "
                         (math "[" "0" "," "∞" ")")))
            (entry (% (heading (code "GL_PACK_SKIP_ROWS")))
                   (para "
integer "
                         ", "
                         "
0 "
                         ", "
                         (math "[" "0" "," "∞" ")")))
            (entry (% (heading (code "GL_PACK_SKIP_PIXELS")))
                   (para "
integer "
                         ", "
                         "
0 "
                         ", "
                         (math "[" "0" "," "∞" ")")))
            (entry (% (heading (code "GL_PACK_SKIP_IMAGES")))
                   (para "
integer "
                         ", "
                         "
0 "
                         ", "
                         (math "[" "0" "," "∞" ")")))
            (entry (% (heading (code "GL_PACK_ALIGNMENT")))
                   (para "
integer "
                         ", "
                         "
4 "
                         ", "
                         "
1, 2, 4, or 8 "))
            (entry (% (heading (code "GL_UNPACK_SWAP_BYTES")))
                   (para "
boolean "
                         ", "
                         "
false "
                         ", "
                         "
true or false "))
            (entry (% (heading (code "GL_UNPACK_LSB_FIRST")))
                   (para "
boolean "
                         ", "
                         "
false "
                         ", "
                         "
true or false "))
            (entry (% (heading (code "GL_UNPACK_ROW_LENGTH")))
                   (para "
integer "
                         ", "
                         "
0 "
                         ", "
                         (math "[" "0" "," "∞" ")")))
            (entry (% (heading (code "GL_UNPACK_IMAGE_HEIGHT")))
                   (para "
integer "
                         ", "
                         "
0 "
                         ", "
                         (math "[" "0" "," "∞" ")")))
            (entry (% (heading (code "GL_UNPACK_SKIP_ROWS")))
                   (para "
integer "
                         ", "
                         "
0 "
                         ", "
                         (math "[" "0" "," "∞" ")")))
            (entry (% (heading (code "GL_UNPACK_SKIP_PIXELS")))
                   (para "
integer "
                         ", "
                         "
0 "
                         ", "
                         (math "[" "0" "," "∞" ")")))
            (entry (% (heading (code "GL_UNPACK_SKIP_IMAGES")))
                   (para "
integer "
                         ", "
                         "
0 "
                         ", "
                         (math "[" "0" "," "∞" ")")))
            (entry (% (heading (code "GL_UNPACK_ALIGNMENT")))
                   (para "
integer "
                         ", "
                         "
4 "
                         ", "
                         "
1, 2, 4, or 8 ")))
     (para (code "glPixelStoref")
           " can be used to set any pixel store parameter.
            If the parameter type is boolean,
            then if "
           (var "param")
           " is 0,
            the parameter is false;
            otherwise it is set to true.
            If "
           (var "pname")
           " is a integer type parameter, "
           (var "param")
           " is rounded to the nearest integer. ")
     (para "
Likewise, "
           (code "glPixelStorei")
           " can also be used to set any of the
            pixel store parameters.
            Boolean parameters are set to false if "
           (var "param")
           " is 0 and true otherwise. ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "pname")
           " is not an accepted value. ")
     (para (code "GL_INVALID_VALUE")
           " is generated if a negative row length,
            pixel skip,
            or row skip value is specified,
            or if alignment is specified as other than 1, 2, 4, or 8. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glPixelStore")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glPixelTransfer
  "glPixelTransfer"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glPixelTransferf"))
      (paramdef "GLenum " (parameter "pname"))
      (paramdef "GLfloat " (parameter "param"))))
  '(*fragment*
     (heading "set pixel transfer modes")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "pname")))
                   (para "
Specifies the symbolic name of the pixel transfer parameter to be set.
                    Must be one of the following: "
                         (code "GL_MAP_COLOR")
                         ", "
                         (code "GL_MAP_STENCIL")
                         ", "
                         (code "GL_INDEX_SHIFT")
                         ", "
                         (code "GL_INDEX_OFFSET")
                         ", "
                         (code "GL_RED_SCALE")
                         ", "
                         (code "GL_RED_BIAS")
                         ", "
                         (code "GL_GREEN_SCALE")
                         ", "
                         (code "GL_GREEN_BIAS")
                         ", "
                         (code "GL_BLUE_SCALE")
                         ", "
                         (code "GL_BLUE_BIAS")
                         ", "
                         (code "GL_ALPHA_SCALE")
                         ", "
                         (code "GL_ALPHA_BIAS")
                         ", "
                         (code "GL_DEPTH_SCALE")
                         ", or "
                         (code "GL_DEPTH_BIAS")
                         ". ")
                   (para "
Additionally, if the "
                         (code "ARB_imaging")
                         " extension is supported, the
                    following symbolic names are accepted: "
                         (code "GL_POST_COLOR_MATRIX_RED_SCALE")
                         ", "
                         (code "GL_POST_COLOR_MATRIX_GREEN_SCALE")
                         ", "
                         (code "GL_POST_COLOR_MATRIX_BLUE_SCALE")
                         ", "
                         (code "GL_POST_COLOR_MATRIX_ALPHA_SCALE")
                         ", "
                         (code "GL_POST_COLOR_MATRIX_RED_BIAS")
                         ", "
                         (code "GL_POST_COLOR_MATRIX_GREEN_BIAS")
                         ", "
                         (code "GL_POST_COLOR_MATRIX_BLUE_BIAS")
                         ", "
                         (code "GL_POST_COLOR_MATRIX_ALPHA_BIAS")
                         ", "
                         (code "GL_POST_CONVOLUTION_RED_SCALE")
                         ", "
                         (code "GL_POST_CONVOLUTION_GREEN_SCALE")
                         ", "
                         (code "GL_POST_CONVOLUTION_BLUE_SCALE")
                         ", "
                         (code "GL_POST_CONVOLUTION_ALPHA_SCALE")
                         ", "
                         (code "GL_POST_CONVOLUTION_RED_BIAS")
                         ", "
                         (code "GL_POST_CONVOLUTION_GREEN_BIAS")
                         ", "
                         (code "GL_POST_CONVOLUTION_BLUE_BIAS")
                         ", and "
                         (code "GL_POST_CONVOLUTION_ALPHA_BIAS")
                         ". "))
            (entry (% (heading (var "param")))
                   (para "
Specifies the value that "
                         (var "pname")
                         " is set to. ")))
     (heading "Description")
     (para (code "glPixelTransfer")
           " sets pixel transfer modes that affect the operation of subsequent "
           (code "glCopyPixels")
           ", "
           (code "glCopyTexImage1D")
           ", "
           (code "glCopyTexImage2D")
           ", "
           (code "glCopyTexSubImage1D")
           ", "
           (code "glCopyTexSubImage2D")
           ", "
           (code "glCopyTexSubImage3D")
           ", "
           (code "glDrawPixels")
           ", "
           (code "glReadPixels")
           ", "
           (code "glTexImage1D")
           ", "
           (code "glTexImage2D")
           ", "
           (code "glTexImage3D")
           ", "
           (code "glTexSubImage1D")
           ", "
           (code "glTexSubImage2D")
           ", and "
           (code "glTexSubImage3D")
           " commands.
            Additionally, if the "
           (code "ARB_imaging")
           " subset is supported, the
            routines "
           (code "glColorTable")
           ", "
           (code "glColorSubTable")
           ", "
           (code "glConvolutionFilter1D")
           ", "
           (code "glConvolutionFilter2D")
           ", "
           (code "glHistogram")
           ", "
           (code "glMinmax")
           ", and "
           (code "glSeparableFilter2D")
           " are also affected.
            The algorithms that are specified by pixel transfer modes operate on
            pixels after they are read from the frame buffer
            ("
           (code "glCopyPixels")
           (code "glCopyTexImage1D")
           ", "
           (code "glCopyTexImage2D")
           ", "
           (code "glCopyTexSubImage1D")
           ", "
           (code "glCopyTexSubImage2D")
           ", "
           (code "glCopyTexSubImage3D")
           ", and "
           (code "glReadPixels")
           "),
            or unpacked from client memory
            ("
           (code "glDrawPixels")
           ", "
           (code "glTexImage1D")
           ", "
           (code "glTexImage2D")
           ", "
           (code "glTexImage3D")
           ", "
           (code "glTexSubImage1D")
           ", "
           (code "glTexSubImage2D")
           ", and "
           (code "glTexSubImage3D")
           ").
            Pixel transfer operations happen in the same order,
            and in the same manner,
            regardless of the command that resulted in the pixel operation.
            Pixel storage modes
            (see "
           (code "glPixelStore")
           ")
            control the unpacking of pixels being read from client memory
            and the packing of pixels being written back into client memory. ")
     (para "
Pixel transfer operations handle four fundamental pixel types: "
           (var "color")
           ", "
           (var "color index")
           ", "
           (var "depth")
           ", and "
           (var "stencil")
           ". "
           (var "Color")
           " pixels consist of four floating-point values
            with unspecified mantissa and exponent sizes,
            scaled such that 0 represents zero intensity
            and 1 represents full intensity. "
           (var "Color indices")
           " comprise a single fixed-point value,
            with unspecified precision to the right of the binary point. "
           (var "Depth")
           " pixels comprise a single floating-point value,
            with unspecified mantissa and exponent sizes,
            scaled such that 0.0 represents the minimum depth buffer value,
            and 1.0 represents the maximum depth buffer value.
            Finally, "
           (var "stencil")
           " pixels comprise a single fixed-point value,
            with unspecified precision to the right of the binary point. ")
     (para "
The pixel transfer operations performed on the four basic pixel types are
            as follows: ")
     (table (% (formatter (asis)))
            (entry (% (heading (var "Color")))
                   (para "
Each of the four color components is multiplied by a scale factor,
                        then added to a bias factor.
                        That is,
                        the red component is multiplied by "
                         (code "GL_RED_SCALE")
                         ",
                        then added to "
                         (code "GL_RED_BIAS")
                         ";
                        the green component is multiplied by "
                         (code "GL_GREEN_SCALE")
                         ",
                        then added to "
                         (code "GL_GREEN_BIAS")
                         ";
                        the blue component is multiplied by "
                         (code "GL_BLUE_SCALE")
                         ",
                        then added to "
                         (code "GL_BLUE_BIAS")
                         "; and
                        the alpha component is multiplied by "
                         (code "GL_ALPHA_SCALE")
                         ",
                        then added to "
                         (code "GL_ALPHA_BIAS")
                         ".
                        After all four color components are scaled and biased,
                        each is clamped to the range "
                         (math "[" "0" "," "1" "]")
                         ".
                        All color, scale, and bias values are specified with "
                         (code "glPixelTransfer")
                         ". ")
                   (para "
If "
                         (code "GL_MAP_COLOR")
                         " is true,
                        each color component is scaled by the size of the corresponding
                        color-to-color map,
                        then replaced by the contents of that map indexed by the scaled component.
                        That is,
                        the red component is scaled by "
                         (code "GL_PIXEL_MAP_R_TO_R_SIZE")
                         ",
                        then replaced by the contents of "
                         (code "GL_PIXEL_MAP_R_TO_R")
                         " indexed by itself.
                        The green component is scaled by "
                         (code "GL_PIXEL_MAP_G_TO_G_SIZE")
                         ",
                        then replaced by the contents of "
                         (code "GL_PIXEL_MAP_G_TO_G")
                         " indexed by itself.
                        The blue component is scaled by "
                         (code "GL_PIXEL_MAP_B_TO_B_SIZE")
                         ",
                        then replaced by the contents of "
                         (code "GL_PIXEL_MAP_B_TO_B")
                         " indexed by itself.
                        And
                        the alpha component is scaled by "
                         (code "GL_PIXEL_MAP_A_TO_A_SIZE")
                         ",
                        then replaced by the contents of "
                         (code "GL_PIXEL_MAP_A_TO_A")
                         " indexed by itself.
                        All components taken from the maps are then clamped to the range "
                         (math "[" "0" "," "1" "]")
                         ". "
                         (code "GL_MAP_COLOR")
                         " is specified with "
                         (code "glPixelTransfer")
                         ".
                        The contents of the various maps are specified with "
                         (code "glPixelMap")
                         ". ")
                   (para "
If the "
                         (code "ARB_imaging")
                         " extension is supported, each of the four
                        color components may be scaled and biased after transformation by the
                        color matrix.
                        That is,
                        the red component is multiplied by "
                         (code "GL_POST_COLOR_MATRIX_RED_SCALE")
                         ",
                        then added to "
                         (code "GL_POST_COLOR_MATRIX_RED_BIAS")
                         ";
                        the green component is multiplied by "
                         (code "GL_POST_COLOR_MATRIX_GREEN_SCALE")
                         ",
                        then added to "
                         (code "GL_POST_COLOR_MATRIX_GREEN_BIAS")
                         ";
                        the blue component is multiplied by "
                         (code "GL_POST_COLOR_MATRIX_BLUE_SCALE")
                         ",
                        then added to "
                         (code "GL_POST_COLOR_MATRIX_BLUE_BIAS")
                         "; and
                        the alpha component is multiplied by "
                         (code "GL_POST_COLOR_MATRIX_ALPHA_SCALE")
                         ",
                        then added to "
                         (code "GL_POST_COLOR_MATRIX_ALPHA_BIAS")
                         ".
                        After all four color components are scaled and biased,
                        each is clamped to the range "
                         (math "[" "0" "," "1" "]")
                         ". ")
                   (para "
Similarly, if the "
                         (code "ARB_imaging")
                         " extension is supported, each of
                        the four color components may be scaled and biased after processing by
                        the enabled convolution filter.
                        That is,
                        the red component is multiplied by "
                         (code "GL_POST_CONVOLUTION_RED_SCALE")
                         ",
                        then added to "
                         (code "GL_POST_CONVOLUTION_RED_BIAS")
                         ";
                        the green component is multiplied by "
                         (code "GL_POST_CONVOLUTION_GREEN_SCALE")
                         ",
                        then added to "
                         (code "GL_POST_CONVOLUTION_GREEN_BIAS")
                         ";
                        the blue component is multiplied by "
                         (code "GL_POST_CONVOLUTION_BLUE_SCALE")
                         ",
                        then added to "
                         (code "GL_POST_CONVOLUTION_BLUE_BIAS")
                         "; and
                        the alpha component is multiplied by "
                         (code "GL_POST_CONVOLUTION_ALPHA_SCALE")
                         ",
                        then added to "
                         (code "GL_POST_CONVOLUTION_ALPHA_BIAS")
                         ".
                        After all four color components are scaled and biased,
                        each is clamped to the range "
                         (math "[" "0" "," "1" "]")
                         ". "))
            (entry (% (heading (var "Color index")))
                   (para "
Each color index is shifted left by "
                         (code "GL_INDEX_SHIFT")
                         " bits; any bits
                        beyond the number of fraction bits carried
                        by the fixed-point index are filled with zeros.
                        If "
                         (code "GL_INDEX_SHIFT")
                         " is negative,
                        the shift is to the right,
                        again zero filled.
                        Then "
                         (code "GL_INDEX_OFFSET")
                         " is added to the index. "
                         (code "GL_INDEX_SHIFT")
                         " and "
                         (code "GL_INDEX_OFFSET")
                         " are specified with "
                         (code "glPixelTransfer")
                         ". ")
                   (para "
From this point, operation diverges depending on the required format of
                        the resulting pixels.
                        If the resulting pixels are to be written to a color index buffer,
                        or if they are being read back to client memory in "
                         (code "GL_COLOR_INDEX")
                         " format,
                        the pixels continue to be treated as indices.
                        If "
                         (code "GL_MAP_COLOR")
                         " is true,
                        each index is masked by "
                         (math "2" "^" (var "n") "-" "1")
                         ",
                        where "
                         (math (var "n"))
                         "
is "
                         (code "GL_PIXEL_MAP_I_TO_I_SIZE")
                         ",
                        then replaced by the contents of "
                         (code "GL_PIXEL_MAP_I_TO_I")
                         " indexed by the
                        masked value. "
                         (code "GL_MAP_COLOR")
                         " is specified with "
                         (code "glPixelTransfer")
                         ".
                        The contents of the index map is specified with "
                         (code "glPixelMap")
                         ". ")
                   (para "
If the resulting pixels are to be written to an RGBA color buffer,
                        or if they are read back to client memory in a format other than "
                         (code "GL_COLOR_INDEX")
                         ",
                        the pixels are converted from indices to colors by referencing the
                        four maps "
                         (code "GL_PIXEL_MAP_I_TO_R")
                         ", "
                         (code "GL_PIXEL_MAP_I_TO_G")
                         ", "
                         (code "GL_PIXEL_MAP_I_TO_B")
                         ", and "
                         (code "GL_PIXEL_MAP_I_TO_A")
                         ".
                        Before being dereferenced,
                        the index is masked by "
                         (math "2" "^" (var "n") "-" "1")
                         ",
                        where "
                         (math (var "n"))
                         "
is "
                         (code "GL_PIXEL_MAP_I_TO_R_SIZE")
                         " for the red map, "
                         (code "GL_PIXEL_MAP_I_TO_G_SIZE")
                         " for the green map, "
                         (code "GL_PIXEL_MAP_I_TO_B_SIZE")
                         " for the blue map, and "
                         (code "GL_PIXEL_MAP_I_TO_A_SIZE")
                         " for the alpha map.
                        All components taken from the maps are then clamped to the range "
                         (math "[" "0" "," "1" "]")
                         ".
                        The contents of the four maps is specified with "
                         (code "glPixelMap")
                         ". "))
            (entry (% (heading (var "Depth")))
                   (para "
Each depth value is multiplied by "
                         (code "GL_DEPTH_SCALE")
                         ",
                        added to "
                         (code "GL_DEPTH_BIAS")
                         ",
                        then clamped to the range "
                         (math "[" "0" "," "1" "]")
                         ". "))
            (entry (% (heading (var "Stencil")))
                   (para "
Each index is shifted "
                         (code "GL_INDEX_SHIFT")
                         " bits just as a color index is,
                        then added to "
                         (code "GL_INDEX_OFFSET")
                         ".
                        If "
                         (code "GL_MAP_STENCIL")
                         " is true,
                        each index is masked by "
                         (math "2" "^" (var "n") "-" "1")
                         ",
                        where "
                         (math (var "n"))
                         "
is "
                         (code "GL_PIXEL_MAP_S_TO_S_SIZE")
                         ",
                        then replaced by the contents of "
                         (code "GL_PIXEL_MAP_S_TO_S")
                         " indexed by the
                        masked value. ")))
     (para "
The following table gives the type,
            initial value,
            and range of valid values for each of the pixel transfer parameters
            that are set with "
           (code "glPixelTransfer")
           ". ")
     (para)
     (table (% (formatter (asis)))
            (entry (% (heading (strong (var "pname"))))
                   (para (strong "Type")
                         ", "
                         (strong "Initial Value")
                         ", "
                         (strong "Valid Range")))
            (entry (% (heading (code "GL_MAP_COLOR")))
                   (para "
boolean "
                         ", "
                         "
false "
                         ", "
                         "
true/false "))
            (entry (% (heading (code "GL_MAP_STENCIL")))
                   (para "
boolean "
                         ", "
                         "
false "
                         ", "
                         "
true/false "))
            (entry (% (heading (code "GL_INDEX_SHIFT")))
                   (para "
integer "
                         ", "
                         "
0 "
                         ", "
                         (math "(" "-" "∞" "," "∞" ")")))
            (entry (% (heading (code "GL_INDEX_OFFSET")))
                   (para "
integer "
                         ", "
                         "
0 "
                         ", "
                         (math "(" "-" "∞" "," "∞" ")")))
            (entry (% (heading (code "GL_RED_SCALE")))
                   (para "
float "
                         ", "
                         "
1 "
                         ", "
                         (math "(" "-" "∞" "," "∞" ")")))
            (entry (% (heading (code "GL_GREEN_SCALE")))
                   (para "
float "
                         ", "
                         "
1 "
                         ", "
                         (math "(" "-" "∞" "," "∞" ")")))
            (entry (% (heading (code "GL_BLUE_SCALE")))
                   (para "
float "
                         ", "
                         "
1 "
                         ", "
                         (math "(" "-" "∞" "," "∞" ")")))
            (entry (% (heading (code "GL_ALPHA_SCALE")))
                   (para "
float "
                         ", "
                         "
1 "
                         ", "
                         (math "(" "-" "∞" "," "∞" ")")))
            (entry (% (heading (code "GL_DEPTH_SCALE")))
                   (para "
float "
                         ", "
                         "
1 "
                         ", "
                         (math "(" "-" "∞" "," "∞" ")")))
            (entry (% (heading (code "GL_RED_BIAS")))
                   (para "
float "
                         ", "
                         "
0 "
                         ", "
                         (math "(" "-" "∞" "," "∞" ")")))
            (entry (% (heading (code "GL_GREEN_BIAS")))
                   (para "
float "
                         ", "
                         "
0 "
                         ", "
                         (math "(" "-" "∞" "," "∞" ")")))
            (entry (% (heading (code "GL_BLUE_BIAS")))
                   (para "
float "
                         ", "
                         "
0 "
                         ", "
                         (math "(" "-" "∞" "," "∞" ")")))
            (entry (% (heading (code "GL_ALPHA_BIAS")))
                   (para "
float "
                         ", "
                         "
0 "
                         ", "
                         (math "(" "-" "∞" "," "∞" ")")))
            (entry (% (heading (code "GL_DEPTH_BIAS")))
                   (para "
float "
                         ", "
                         "
0 "
                         ", "
                         (math "(" "-" "∞" "," "∞" ")")))
            (entry (% (heading (code "GL_POST_COLOR_MATRIX_RED_SCALE")))
                   (para "
float "
                         ", "
                         "
1 "
                         ", "
                         (math "(" "-" "∞" "," "∞" ")")))
            (entry (% (heading
                        (code "GL_POST_COLOR_MATRIX_GREEN_SCALE")))
                   (para "
float "
                         ", "
                         "
1 "
                         ", "
                         (math "(" "-" "∞" "," "∞" ")")))
            (entry (% (heading
                        (code "GL_POST_COLOR_MATRIX_BLUE_SCALE")))
                   (para "
float "
                         ", "
                         "
1 "
                         ", "
                         (math "(" "-" "∞" "," "∞" ")")))
            (entry (% (heading
                        (code "GL_POST_COLOR_MATRIX_ALPHA_SCALE")))
                   (para "
float "
                         ", "
                         "
1 "
                         ", "
                         (math "(" "-" "∞" "," "∞" ")")))
            (entry (% (heading (code "GL_POST_COLOR_MATRIX_RED_BIAS")))
                   (para "
float "
                         ", "
                         "
0 "
                         ", "
                         (math "(" "-" "∞" "," "∞" ")")))
            (entry (% (heading
                        (code "GL_POST_COLOR_MATRIX_GREEN_BIAS")))
                   (para "
float "
                         ", "
                         "
0 "
                         ", "
                         (math "(" "-" "∞" "," "∞" ")")))
            (entry (% (heading (code "GL_POST_COLOR_MATRIX_BLUE_BIAS")))
                   (para "
float "
                         ", "
                         "
0 "
                         ", "
                         (math "(" "-" "∞" "," "∞" ")")))
            (entry (% (heading
                        (code "GL_POST_COLOR_MATRIX_ALPHA_BIAS")))
                   (para "
float "
                         ", "
                         "
0 "
                         ", "
                         (math "(" "-" "∞" "," "∞" ")")))
            (entry (% (heading (code "GL_POST_CONVOLUTION_RED_SCALE")))
                   (para "
float "
                         ", "
                         "
1 "
                         ", "
                         (math "(" "-" "∞" "," "∞" ")")))
            (entry (% (heading
                        (code "GL_POST_CONVOLUTION_GREEN_SCALE")))
                   (para "
float "
                         ", "
                         "
1 "
                         ", "
                         (math "(" "-" "∞" "," "∞" ")")))
            (entry (% (heading (code "GL_POST_CONVOLUTION_BLUE_SCALE")))
                   (para "
float "
                         ", "
                         "
1 "
                         ", "
                         (math "(" "-" "∞" "," "∞" ")")))
            (entry (% (heading
                        (code "GL_POST_CONVOLUTION_ALPHA_SCALE")))
                   (para "
float "
                         ", "
                         "
1 "
                         ", "
                         (math "(" "-" "∞" "," "∞" ")")))
            (entry (% (heading (code "GL_POST_CONVOLUTION_RED_BIAS")))
                   (para "
float "
                         ", "
                         "
0 "
                         ", "
                         (math "(" "-" "∞" "," "∞" ")")))
            (entry (% (heading (code "GL_POST_CONVOLUTION_GREEN_BIAS")))
                   (para "
float "
                         ", "
                         "
0 "
                         ", "
                         (math "(" "-" "∞" "," "∞" ")")))
            (entry (% (heading (code "GL_POST_CONVOLUTION_BLUE_BIAS")))
                   (para "
float "
                         ", "
                         "
0 "
                         ", "
                         (math "(" "-" "∞" "," "∞" ")")))
            (entry (% (heading (code "GL_POST_CONVOLUTION_ALPHA_BIAS")))
                   (para "
float "
                         ", "
                         "
0 "
                         ", "
                         (math "(" "-" "∞" "," "∞" ")"))))
     (para (code "glPixelTransferf")
           " can be used to set any pixel transfer parameter.
            If the parameter type is boolean,
            0 implies false and any other value implies true.
            If "
           (var "pname")
           " is an integer parameter, "
           (var "param")
           " is rounded to the nearest integer. ")
     (para "
Likewise, "
           (code "glPixelTransferi")
           " can be used to set any of the
            pixel transfer parameters.
            Boolean parameters are set to false if "
           (var "param")
           " is 0 and to true otherwise. "
           (var "param")
           " is converted to floating point before being assigned to real-valued parameters. ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "pname")
           " is not an accepted value. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glPixelTransfer")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glPixelZoom
  "glPixelZoom"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glPixelZoom"))
      (paramdef "GLfloat " (parameter "xfactor"))
      (paramdef "GLfloat " (parameter "yfactor"))))
  '(*fragment*
     (heading "specify the pixel zoom factors")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "xfactor")))
                   (itemx (var "yfactor"))
                   (para "
Specify the "
                         (math (var "x"))
                         "
and "
                         (math (var "y"))
                         "
zoom factors for pixel write operations. ")))
     (heading "Description")
     (para (code "glPixelZoom")
           " specifies values for the "
           (math (var "x"))
           "
and "
           (math (var "y"))
           "
zoom factors.
            During the execution of "
           (code "glDrawPixels")
           " or "
           (code "glCopyPixels")
           ",
            if 
            ("
           (math (var "xr"))
           ", "
           (math (var "yr"))
           ")
            is the current raster position,
            and a given element is in the "
           (math (var "m"))
           "th
            row and "
           (math (var "n"))
           "th
            column of the pixel rectangle,
            then pixels whose centers are in the rectangle with corners at ")
     (para "
("
           (math (var "xr")
                 "+"
                 (var "n")
                 "·"
                 (var "xfactor"))
           ", "
           (math (var "yr")
                 "+"
                 (var "m")
                 "·"
                 (var "yfactor"))
           ") ")
     (para "
("
           (math (var "xr")
                 "+"
                 "("
                 (var "n")
                 "+"
                 "1"
                 ","
                 ")"
                 "·"
                 (var "xfactor"))
           ", "
           (math (var "yr")
                 "+"
                 "("
                 (var "m")
                 "+"
                 "1"
                 ","
                 ")"
                 "·"
                 (var "yfactor"))
           ") ")
     (para "
are candidates for replacement.
            Any pixel whose center lies on the bottom or left edge of this rectangular
            region is also modified. ")
     (para "
Pixel zoom factors are not limited to positive values.
            Negative zoom factors reflect the resulting image about the current
            raster position. ")
     (heading "Errors")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glPixelZoom")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glPointParameter
  "glPointParameter"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glPointParameterf"))
      (paramdef "GLenum " (parameter "pname"))
      (paramdef "GLfloat " (parameter "param"))))
  '(*fragment*
     (heading "specify point parameters")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "pname")))
                   (para "
Specifies a single-valued point parameter. "
                         (code "GL_POINT_SIZE_MIN")
                         ", "
                         (code "GL_POINT_SIZE_MAX")
                         ", "
                         (code "GL_POINT_FADE_THRESHOLD_SIZE")
                         ", and "
                         (code "GL_POINT_SPRITE_COORD_ORIGIN")
                         "
are accepted. "))
            (entry (% (heading (var "param")))
                   (para "
Specifies the value that "
                         (var "pname")
                         " will be set to. ")))
     (heading "Description")
     (para "
The following values are accepted for "
           (var "pname")
           ": ")
     (table (% (formatter (asis)))
            (entry (% (heading (code "GL_POINT_SIZE_MIN")))
                   (para)
                   (para (var "params")
                         " is a single floating-point value that specifies the minimum point size.  The default value is 0.0. "))
            (entry (% (heading (code "GL_POINT_SIZE_MAX")))
                   (para)
                   (para (var "params")
                         " is a single floating-point value that specifies the maximum point size.  The default value is 1.0. "))
            (entry (% (heading (code "GL_POINT_FADE_THRESHOLD_SIZE")))
                   (para)
                   (para (var "params")
                         " is a single floating-point value that specifies the threshold value
                        to which point sizes are clamped if they exceed the specified value.  The
                        default value is 1.0. "))
            (entry (% (heading (code "GL_POINT_DISTANCE_ATTENUATION")))
                   (para)
                   (para (var "params")
                         " is an array of three floating-point values that specify the
                        coefficients used for scaling the computed point size.  The default values
                        are "
                         (math "(" "1" "," "0" "0" ")")
                         ". "))
            (entry (% (heading (code "GL_POINT_SPRITE_COORD_ORIGIN")))
                   (para)
                   (para (var "params")
                         " is a single enum specifying the point sprite texture coordinate origin, either "
                         (code "GL_LOWER_LEFT")
                         " or "
                         (code "GL_UPPER_LEFT")
                         ". 
                        The default value is "
                         (code "GL_UPPER_LEFT")
                         ". ")))
     (heading "Errors")
     (para (code "GL_INVALID_VALUE")
           " is generated If the value specified for "
           (code "GL_POINT_SIZE_MIN")
           ", "
           (code "GL_POINT_SIZE_MAX")
           ", or "
           (code "GL_POINT_FADE_THRESHOLD_SIZE")
           " is less than zero. ")
     (para (code "GL_INVALID_ENUM")
           " is generated If the value specified for "
           (code "GL_POINT_SPRITE_COORD_ORIGIN")
           " is not "
           (code "GL_LOWER_LEFT")
           " or "
           (code "GL_UPPER_LEFT")
           ". ")
     (para "
If the value for "
           (code "GL_POINT_SIZE_MIN")
           " is greater than "
           (code "GL_POINT_SIZE_MAX")
           ", the point size after clamping is undefined, but no
            error is generated. ")
     (para)))

(define-gl-procedure
  glPointSize
  "glPointSize"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glPointSize"))
      (paramdef "GLfloat " (parameter "size"))))
  '(*fragment*
     (heading
       "specify the diameter of rasterized points")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "size")))
                   (para "
Specifies the diameter of rasterized points.
                    The initial value is 1. ")))
     (heading "Description")
     (para (code "glPointSize")
           " specifies the rasterized diameter of both aliased and antialiased
            points.  Using a point size other than 1 has different effects, depending
            on whether point antialiasing is enabled.  To enable and disable point
            antialiasing, call "
           (code "glEnable")
           " and "
           (code "glDisable")
           " with argument "
           (code "GL_POINT_SMOOTH")
           ". Point antialiasing is initially disabled. ")
     (para "
The specified point size is multiplied with a distance attenuation factor
            and clamped to the specified point size range, and further clamped to the
            implementation-dependent point size range to produce the derived point size
            using ")
     (para (math (var "pointSize")
                 "="
                 (var "clamp")
                 "\u2062"
                 "("
                 (var "size")
                 "×"
                 "√"
                 "("
                 "1"
                 "/"
                 (var "a")
                 "+"
                 (var "b")
                 "×"
                 (var "d")
                 "+"
                 (var "c")
                 "×"
                 (var "d")
                 "^"
                 "2"
                 ","
                 ","
                 ","
                 ")"
                 ","
                 ","
                 ")"))
     (para "
where "
           (math (var "d"))
           "
is the eye-coordinate distance from the eye to the vertex, and "
           (math (var "a"))
           ", "
           (math (var "b"))
           ",
            and "
           (math (var "c"))
           "
are the distance attenuation coefficients (see "
           (code "glPointParameter")
           "). ")
     (para "
If multisampling is disabled, the computed point size is used as the
            point's width. ")
     (para "
If multisampling is enabled, the point may be faded by modifying the point
            alpha value (see "
           (code "glSampleCoverage")
           ") instead of allowing the point width
            to go below a given threshold (see "
           (code "glPointParameter")
           ").  In this case,
            the width is further modified in the following manner: ")
     (para (math (var "pointWidth")
                 "="
                 "{"
                 "("
                 (var "pointSize")
                 ")"
                 ", "
                 "("
                 (var "threshold")
                 ")"
                 "\u2062"
                 "("
                 (var "pointSize")
                 ">="
                 (var "threshold")
                 ")"
                 ", "
                 "("
                 (var "otherwise")
                 ")"
                 ","))
     (para "
The point alpha value is modified by computing: ")
     (para (math (var "pointAlpha")
                 "="
                 "{"
                 "("
                 "1"
                 ")"
                 ", "
                 "("
                 "("
                 (var "pointSize")
                 "/"
                 (var "threshold")
                 ","
                 ")"
                 "^"
                 "2"
                 ")"
                 "\u2062"
                 "("
                 (var "pointSize")
                 ">="
                 (var "threshold")
                 ")"
                 ", "
                 "("
                 (var "otherwise")
                 ")"
                 ","))
     (para "
If point antialiasing is disabled, the actual size is determined by
            rounding the supplied size to the nearest integer.  (If the rounding
            results in the value 0, it is as if the point size were 1.)  If the rounded
            size is odd, then the center point 
            ("
           (math (var "x"))
           ", "
           (math (var "y"))
           ")
            of the pixel fragment
            that represents the point is computed as ")
     (para (math "("
                 "⌊"
                 (var "x")
                 "_"
                 (var "w")
                 ","
                 "⌋"
                 "+"
                 ".5"
                 ","
                 "⌊"
                 (var "y")
                 "_"
                 (var "w")
                 ","
                 "⌋"
                 "+"
                 ".5"
                 ")"))
     (para "
where "
           (math (var "w"))
           "
subscripts indicate window coordinates.  All pixels that lie
            within the square grid of the rounded size centered at 
            ("
           (math (var "x"))
           ", "
           (math (var "y"))
           ")
            make
            up the fragment.  If the size is even, the center point is ")
     (para (math "("
                 "⌊"
                 (var "x")
                 "_"
                 (var "w")
                 "+"
                 ".5"
                 ","
                 "⌋"
                 ","
                 "⌊"
                 (var "y")
                 "_"
                 (var "w")
                 "+"
                 ".5"
                 ","
                 "⌋"
                 ")"))
     (para "
and the rasterized fragment's centers are the half-integer window
            coordinates within the square of the rounded size centered at "
           (math "(" (var "x") "," (var "y") ")")
           ".
            All pixel fragments produced in rasterizing a nonantialiased point are
            assigned the same associated data, that of the vertex corresponding to the
            point. ")
     (para "
If antialiasing is enabled, then point rasterization produces a fragment
            for each pixel square that intersects the region lying within the circle
            having diameter equal to the current point size and centered at the point's "
           (math "("
                 (var "x")
                 "_"
                 (var "w")
                 ","
                 (var "y")
                 "_"
                 (var "w")
                 ")")
           ".
            The coverage value for each fragment is the
            window coordinate area of the intersection of the circular region with the
            corresponding pixel square.  This value is saved and used in the final
            rasterization step.  The data associated with each fragment is the data
            associated with the point being rasterized. ")
     (para "
Not all sizes are supported when point antialiasing is enabled.  If an
            unsupported size is requested, the nearest supported size is used.  Only
            size 1 is guaranteed to be supported; others depend on the implementation.
            To query the range of supported sizes and the size difference between
            supported sizes within the range, call "
           (code "glGet")
           " with arguments "
           (code "GL_SMOOTH_POINT_SIZE_RANGE")
           " and "
           (code "GL_SMOOTH_POINT_SIZE_GRANULARITY")
           ".
            For aliased points, query the supported ranges and granularity with "
           (code "glGet")
           " with arguments "
           (code "GL_ALIASED_POINT_SIZE_RANGE")
           ". ")
     (heading "Errors")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "size")
           " is less than or equal to 0. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glPointSize")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glPolygonMode
  "glPolygonMode"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glPolygonMode"))
      (paramdef "GLenum " (parameter "face"))
      (paramdef "GLenum " (parameter "mode"))))
  '(*fragment*
     (heading "select a polygon rasterization mode")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "face")))
                   (para "
Specifies the polygons that "
                         (var "mode")
                         " applies to.
                    Must be "
                         (code "GL_FRONT")
                         " for front-facing polygons, "
                         (code "GL_BACK")
                         " for back-facing polygons,
                    or "
                         (code "GL_FRONT_AND_BACK")
                         " for front- and back-facing polygons. "))
            (entry (% (heading (var "mode")))
                   (para "
Specifies how polygons will be rasterized.
                    Accepted values are "
                         (code "GL_POINT")
                         ", "
                         (code "GL_LINE")
                         ", and "
                         (code "GL_FILL")
                         ".
                    The initial value is "
                         (code "GL_FILL")
                         " for both front- and back-facing polygons. ")))
     (heading "Description")
     (para (code "glPolygonMode")
           " controls the interpretation of polygons for rasterization. "
           (var "face")
           " describes which polygons "
           (var "mode")
           " applies to:
            front-facing polygons ("
           (code "GL_FRONT")
           "),
            back-facing polygons ("
           (code "GL_BACK")
           "),
            or both ("
           (code "GL_FRONT_AND_BACK")
           ").
            The polygon mode affects only the final rasterization of polygons.
            In particular,
            a polygon's vertices are lit and
            the polygon is clipped and possibly culled before these modes are applied. ")
     (para "
Three modes are defined and can be specified in "
           (var "mode")
           ": ")
     (table (% (formatter (asis)))
            (entry (% (heading (code "GL_POINT")))
                   (para "
Polygon vertices that are marked as the start of a boundary edge
                        are drawn as points.
                        Point attributes such as "
                         (code "GL_POINT_SIZE")
                         " and "
                         (code "GL_POINT_SMOOTH")
                         " control
                        the rasterization of the points.
                        Polygon rasterization attributes other than "
                         (code "GL_POLYGON_MODE")
                         " have no effect. "))
            (entry (% (heading (code "GL_LINE")))
                   (para "
Boundary edges of the polygon are drawn as line segments.
                        They are treated as connected line segments for line stippling;
                        the line stipple counter and pattern are not reset between segments
                        (see "
                         (code "glLineStipple")
                         ").
                        Line attributes such as "
                         (code "GL_LINE_WIDTH")
                         " and "
                         (code "GL_LINE_SMOOTH")
                         " control
                        the rasterization of the lines.
                        Polygon rasterization attributes other than "
                         (code "GL_POLYGON_MODE")
                         " have no effect. "))
            (entry (% (heading (code "GL_FILL")))
                   (para "
The interior of the polygon is filled.
                        Polygon attributes such as "
                         (code "GL_POLYGON_STIPPLE")
                         " and "
                         (code "GL_POLYGON_SMOOTH")
                         " control the rasterization of the polygon. ")))
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if either "
           (var "face")
           " or "
           (var "mode")
           " is not
            an accepted value. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glPolygonMode")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glPolygonOffset
  "glPolygonOffset"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glPolygonOffset"))
      (paramdef "GLfloat " (parameter "factor"))
      (paramdef "GLfloat " (parameter "units"))))
  '(*fragment*
     (heading
       "set the scale and units used to calculate depth values")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "factor")))
                   (para "
Specifies a scale factor that is used to create a variable
                    depth offset for each polygon. The initial value is 0. "))
            (entry (% (heading (var "units")))
                   (para "
Is multiplied by an implementation-specific value to
                    create a constant depth offset. The initial value is 0. ")))
     (heading "Description")
     (para "
When "
           (code "GL_POLYGON_OFFSET_FILL")
           ", "
           (code "GL_POLYGON_OFFSET_LINE")
           ", or "
           (code "GL_POLYGON_OFFSET_POINT")
           " is enabled, each
            fragment's "
           (var "depth")
           " value will be offset after it is interpolated
            from the "
           (var "depth")
           " values of the appropriate vertices.
            The value of the offset is "
           (math (var "factor")
                 "×"
                 (var "DZ")
                 "+"
                 (var "r")
                 "×"
                 (var "units"))
           ",
            where "
           (math (var "DZ"))
           "
is a measurement of the change in depth relative to the screen
            area of the polygon, and "
           (math (var "r"))
           "
is the smallest value that is guaranteed to
            produce a resolvable offset for a given implementation.
            The offset is added before the depth test is performed and before
            the value is written into the depth buffer. ")
     (para (code "glPolygonOffset")
           " is useful for rendering hidden-line images, for applying decals
            to surfaces, and for rendering solids with highlighted edges. ")
     (heading "Errors")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glPolygonOffset")
           " is executed
            between the execution of "
           (code "glBegin")
           " and the corresponding
            execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glPolygonStipple
  "glPolygonStipple"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glPolygonStipple"))
      (paramdef
        "const GLubyte * "
        (parameter "pattern"))))
  '(*fragment*
     (heading "set the polygon stippling pattern")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "pattern")))
                   (para "
Specifies a pointer to a "
                         (math "32" "×" "32")
                         "
stipple pattern that will be unpacked
                    from memory in the same way that "
                         (code "glDrawPixels")
                         " unpacks pixels. ")))
     (heading "Description")
     (para "
Polygon stippling,
            like line stippling
            (see "
           (code "glLineStipple")
           "),
            masks out certain fragments produced by rasterization,
            creating a pattern.
            Stippling is independent of polygon antialiasing. ")
     (para (var "pattern")
           " is a pointer to a "
           (math "32" "×" "32")
           "
stipple pattern that is stored
            in memory just like the pixel data supplied to a "
           (code "glDrawPixels")
           "
call with "
           ""
           "
height
            and "
           (var "width")
           "
both equal to 32, a pixel format
            of "
           (code "GL_COLOR_INDEX")
           ", and data type
            of "
           (code "GL_BITMAP")
           ".
            That is,
            the stipple pattern is represented as a "
           (math "32" "×" "32")
           "
array
            of 1-bit color indices packed in unsigned bytes. "
           (code "glPixelStore")
           " parameters like "
           (code "GL_UNPACK_SWAP_BYTES")
           "
and "
           (code "GL_UNPACK_LSB_FIRST")
           " affect the assembling of the bits into a
            stipple pattern.
            Pixel transfer operations
            (shift, offset, pixel map)
            are not applied to the stipple image,
            however. ")
     (para "
If a non-zero named buffer object is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target 
            (see "
           (code "glBindBuffer")
           ") while a stipple pattern is
            specified, "
           (var "pattern")
           " is treated as a byte offset into the buffer object's data store. ")
     (para "
To enable and disable polygon stippling, call "
           (code "glEnable")
           " and "
           (code "glDisable")
           "
with argument "
           (code "GL_POLYGON_STIPPLE")
           ". Polygon stippling is initially
            disabled. If it's enabled,
            a rasterized polygon fragment with window coordinates "
           (math (var "x") "_" (var "w"))
           "
and "
           (math (var "y") "_" (var "w"))
           "
is sent to the next stage of the GL if and only if the
            ("
           (math (var "x") "_" (var "w") "%" "32")
           ")th
            bit in the 
            ("
           (math (var "y") "_" (var "w") "%" "32")
           ")th
            row
            of the stipple pattern is 1 (one).
            When polygon stippling is disabled, it is as if the stipple pattern
            consists of all 1's. ")
     (heading "Errors")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target and the buffer object's data store is currently mapped. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target and the data would be unpacked from the buffer 
            object such that the memory reads required would exceed the data store size. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glPolygonStipple")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glPrioritizeTextures
  "glPrioritizeTextures"
  (funcsynopsis
    (funcprototype
      (funcdef
        "void "
        (function "glPrioritizeTextures"))
      (paramdef "GLsizei " (parameter "n"))
      (paramdef
        "const GLuint * "
        (parameter "textures"))
      (paramdef
        "const GLclampf * "
        (parameter "priorities"))))
  '(*fragment*
     (heading "set texture residence priority")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "n")))
                   (para "
Specifies the number of textures to be prioritized. "))
            (entry (% (heading (var "textures")))
                   (para "
Specifies an array containing the names of the textures to be prioritized. "))
            (entry (% (heading (var "priorities")))
                   (para "
Specifies an array containing the texture priorities.
                    A priority given in an element of "
                         (var "priorities")
                         " applies to the texture
                    named by the corresponding element of "
                         (var "textures")
                         ". ")))
     (heading "Description")
     (para (code "glPrioritizeTextures")
           " assigns the "
           (var "n")
           " texture priorities given in "
           (var "priorities")
           " to the "
           (var "n")
           " textures named in "
           (var "textures")
           ". ")
     (para "
The GL establishes
            a ``working set'' of textures that are resident in texture memory.
            These textures may be bound to a texture target much more efficiently
            than textures that are not resident.
            By specifying a priority for each texture, "
           (code "glPrioritizeTextures")
           " allows applications to guide the GL implementation in determining
            which textures should be resident. ")
     (para "
The priorities given in "
           (var "priorities")
           " are clamped to the range "
           (math "[" "0" "," "1" "]")
           "
before they are assigned.
            0 indicates the lowest priority; textures with priority 0
            are least likely to be resident.
            1 indicates the highest priority; textures with priority 1
            are most likely to be resident.
            However, textures are not guaranteed to be resident until they are used. ")
     (para (code "glPrioritizeTextures")
           " silently ignores attempts to prioritize texture 0 or any texture
            name that does not correspond to an existing texture. ")
     (para (code "glPrioritizeTextures")
           " does not require that any of the textures named by "
           (var "textures")
           "
be bound to a texture target. "
           (code "glTexParameter")
           " may also be used to set a texture's priority,
            but only if the texture is currently bound.
            This is the only way to set the priority of a default texture. ")
     (heading "Errors")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "n")
           " is negative. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glPrioritizeTextures")
           " is executed
            between the execution of "
           (code "glBegin")
           " and the corresponding
            execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glPushAttrib
  "glPushAttrib"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glPushAttrib"))
      (paramdef "GLbitfield " (parameter "mask"))))
  '(*fragment*
     (heading
       "push and pop the server attribute stack")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "mask")))
                   (para "
Specifies a mask that indicates which attributes to save. Values for "
                         (var "mask")
                         " are listed below. ")))
     (heading "Description")
     (para (code "glPushAttrib")
           " takes one argument,
            a mask that indicates which groups of state variables
            to save on the attribute stack.
            Symbolic constants are used to set bits in the mask. "
           (var "mask")
           "
is typically constructed by specifying the bitwise-or of several 
            of these constants together.
            The special mask "
           (code "GL_ALL_ATTRIB_BITS")
           "
can be used to save all stackable states. ")
     (para "
The symbolic mask constants and their associated GL state are as follows
            (the second column lists which attributes are saved): ")
     (para)
     (table (% (formatter (asis)))
            (entry (% (heading (code "GL_ACCUM_BUFFER_BIT")))
                   (para "
Accumulation buffer clear value "))
            (entry (% (heading (code "GL_COLOR_BUFFER_BIT")))
                   (para (code "GL_ALPHA_TEST") " enable bit "))
            (entry (% (heading))
                   (para "
Alpha test function and reference value "))
            (entry (% (heading))
                   (para (code "GL_BLEND") " enable bit "))
            (entry (% (heading))
                   (para "
Blending source and destination functions "))
            (entry (% (heading))
                   (para "
Constant blend color "))
            (entry (% (heading))
                   (para "
Blending equation "))
            (entry (% (heading))
                   (para (code "GL_DITHER") " enable bit "))
            (entry (% (heading))
                   (para (code "GL_DRAW_BUFFER") " setting "))
            (entry (% (heading))
                   (para (code "GL_COLOR_LOGIC_OP") " enable bit "))
            (entry (% (heading))
                   (para (code "GL_INDEX_LOGIC_OP") " enable bit "))
            (entry (% (heading))
                   (para "
Logic op function "))
            (entry (% (heading))
                   (para "
Color mode and index mode clear values "))
            (entry (% (heading))
                   (para "
Color mode and index mode writemasks "))
            (entry (% (heading (code "GL_CURRENT_BIT")))
                   (para "
Current RGBA color "))
            (entry (% (heading))
                   (para "
Current color index "))
            (entry (% (heading))
                   (para "
Current normal vector "))
            (entry (% (heading))
                   (para "
Current texture coordinates "))
            (entry (% (heading))
                   (para "
Current raster position "))
            (entry (% (heading))
                   (para (code "GL_CURRENT_RASTER_POSITION_VALID")
                         " flag "))
            (entry (% (heading))
                   (para "
RGBA color associated with current raster position "))
            (entry (% (heading))
                   (para "
Color index associated with current raster position "))
            (entry (% (heading))
                   (para "
Texture coordinates associated with current raster position "))
            (entry (% (heading))
                   (para (code "GL_EDGE_FLAG") " flag "))
            (entry (% (heading (code "GL_DEPTH_BUFFER_BIT")))
                   (para (code "GL_DEPTH_TEST") " enable bit "))
            (entry (% (heading))
                   (para "
Depth buffer test function "))
            (entry (% (heading))
                   (para "
Depth buffer clear value "))
            (entry (% (heading))
                   (para (code "GL_DEPTH_WRITEMASK") " enable bit "))
            (entry (% (heading (code "GL_ENABLE_BIT")))
                   (para (code "GL_ALPHA_TEST") " flag "))
            (entry (% (heading))
                   (para (code "GL_AUTO_NORMAL") " flag "))
            (entry (% (heading))
                   (para (code "GL_BLEND") " flag "))
            (entry (% (heading))
                   (para "
Enable bits for the user-definable clipping planes "))
            (entry (% (heading))
                   (para (code "GL_COLOR_MATERIAL")))
            (entry (% (heading))
                   (para (code "GL_CULL_FACE") " flag "))
            (entry (% (heading))
                   (para (code "GL_DEPTH_TEST") " flag "))
            (entry (% (heading))
                   (para (code "GL_DITHER") " flag "))
            (entry (% (heading))
                   (para (code "GL_FOG") " flag "))
            (entry (% (heading))
                   (para (code "GL_LIGHT")
                         (var "i")
                         "
where "
                         (code "0")
                         " <= "
                         (var "i")
                         " < "
                         (code "GL_MAX_LIGHTS")))
            (entry (% (heading))
                   (para (code "GL_LIGHTING") " flag "))
            (entry (% (heading))
                   (para (code "GL_LINE_SMOOTH") " flag "))
            (entry (% (heading))
                   (para (code "GL_LINE_STIPPLE") " flag "))
            (entry (% (heading))
                   (para (code "GL_COLOR_LOGIC_OP") " flag "))
            (entry (% (heading))
                   (para (code "GL_INDEX_LOGIC_OP") " flag "))
            (entry (% (heading))
                   (para (code "GL_MAP1_")
                         (var "x")
                         " where "
                         (var "x")
                         " is a map type "))
            (entry (% (heading))
                   (para (code "GL_MAP2_")
                         (var "x")
                         " where "
                         (var "x")
                         " is a map type "))
            (entry (% (heading))
                   (para (code "GL_MULTISAMPLE") " flag "))
            (entry (% (heading))
                   (para (code "GL_NORMALIZE") " flag "))
            (entry (% (heading))
                   (para (code "GL_POINT_SMOOTH") " flag "))
            (entry (% (heading))
                   (para (code "GL_POLYGON_OFFSET_LINE") " flag "))
            (entry (% (heading))
                   (para (code "GL_POLYGON_OFFSET_FILL") " flag "))
            (entry (% (heading))
                   (para (code "GL_POLYGON_OFFSET_POINT") " flag "))
            (entry (% (heading))
                   (para (code "GL_POLYGON_SMOOTH") " flag "))
            (entry (% (heading))
                   (para (code "GL_POLYGON_STIPPLE") " flag "))
            (entry (% (heading))
                   (para (code "GL_SAMPLE_ALPHA_TO_COVERAGE")
                         " flag "))
            (entry (% (heading))
                   (para (code "GL_SAMPLE_ALPHA_TO_ONE") " flag "))
            (entry (% (heading))
                   (para (code "GL_SAMPLE_COVERAGE") " flag "))
            (entry (% (heading))
                   (para (code "GL_SCISSOR_TEST") " flag "))
            (entry (% (heading))
                   (para (code "GL_STENCIL_TEST") " flag "))
            (entry (% (heading))
                   (para (code "GL_TEXTURE_1D") " flag "))
            (entry (% (heading))
                   (para (code "GL_TEXTURE_2D") " flag "))
            (entry (% (heading))
                   (para (code "GL_TEXTURE_3D") " flag "))
            (entry (% (heading))
                   (para "
Flags "
                         (code "GL_TEXTURE_GEN_")
                         (var "x")
                         " where "
                         (var "x")
                         " is S, T, R, or Q "))
            (entry (% (heading (code "GL_EVAL_BIT")))
                   (para (code "GL_MAP1_")
                         (var "x")
                         " enable bits, where "
                         (var "x")
                         " is a map type "))
            (entry (% (heading))
                   (para (code "GL_MAP2_")
                         (var "x")
                         " enable bits, where "
                         (var "x")
                         " is a map type "))
            (entry (% (heading))
                   (para "
1D grid endpoints and divisions "))
            (entry (% (heading))
                   (para "
2D grid endpoints and divisions "))
            (entry (% (heading))
                   (para (code "GL_AUTO_NORMAL") " enable bit "))
            (entry (% (heading (code "GL_FOG_BIT")))
                   (para (code "GL_FOG") " enable bit "))
            (entry (% (heading)) (para "
Fog color "))
            (entry (% (heading)) (para "
Fog density "))
            (entry (% (heading)) (para "
Linear fog start "))
            (entry (% (heading)) (para "
Linear fog end "))
            (entry (% (heading)) (para "
Fog index "))
            (entry (% (heading))
                   (para (code "GL_FOG_MODE") " value "))
            (entry (% (heading (code "GL_HINT_BIT")))
                   (para (code "GL_PERSPECTIVE_CORRECTION_HINT")
                         " setting "))
            (entry (% (heading))
                   (para (code "GL_POINT_SMOOTH_HINT") " setting "))
            (entry (% (heading))
                   (para (code "GL_LINE_SMOOTH_HINT") " setting "))
            (entry (% (heading))
                   (para (code "GL_POLYGON_SMOOTH_HINT")
                         " setting "))
            (entry (% (heading))
                   (para (code "GL_FOG_HINT") " setting "))
            (entry (% (heading))
                   (para (code "GL_GENERATE_MIPMAP_HINT")
                         " setting "))
            (entry (% (heading))
                   (para (code "GL_TEXTURE_COMPRESSION_HINT")
                         " setting "))
            (entry (% (heading (code "GL_LIGHTING_BIT")))
                   (para (code "GL_COLOR_MATERIAL") " enable bit "))
            (entry (% (heading))
                   (para (code "GL_COLOR_MATERIAL_FACE") " value "))
            (entry (% (heading))
                   (para "
Color material parameters that are tracking the current color "))
            (entry (% (heading))
                   (para "
Ambient scene color "))
            (entry (% (heading))
                   (para (code "GL_LIGHT_MODEL_LOCAL_VIEWER")
                         " value "))
            (entry (% (heading))
                   (para (code "GL_LIGHT_MODEL_TWO_SIDE")
                         " setting "))
            (entry (% (heading))
                   (para (code "GL_LIGHTING") " enable bit "))
            (entry (% (heading))
                   (para "
Enable bit for each light "))
            (entry (% (heading))
                   (para "
Ambient, diffuse, and specular intensity for each light "))
            (entry (% (heading))
                   (para "
Direction, position, exponent, and cutoff angle for each light "))
            (entry (% (heading))
                   (para "
Constant, linear, and quadratic attenuation factors for each light "))
            (entry (% (heading))
                   (para "
Ambient, diffuse, specular, and emissive color for each material "))
            (entry (% (heading))
                   (para "
Ambient, diffuse, and specular color indices for each material "))
            (entry (% (heading))
                   (para "
Specular exponent for each material "))
            (entry (% (heading))
                   (para (code "GL_SHADE_MODEL") " setting "))
            (entry (% (heading (code "GL_LINE_BIT")))
                   (para (code "GL_LINE_SMOOTH") " flag "))
            (entry (% (heading))
                   (para (code "GL_LINE_STIPPLE") " enable bit "))
            (entry (% (heading))
                   (para "
Line stipple pattern and repeat counter "))
            (entry (% (heading)) (para "
Line width "))
            (entry (% (heading (code "GL_LIST_BIT")))
                   (para (code "GL_LIST_BASE") " setting "))
            (entry (% (heading (code "GL_MULTISAMPLE_BIT")))
                   (para (code "GL_MULTISAMPLE") " flag "))
            (entry (% (heading))
                   (para (code "GL_SAMPLE_ALPHA_TO_COVERAGE")
                         " flag "))
            (entry (% (heading))
                   (para (code "GL_SAMPLE_ALPHA_TO_ONE") " flag "))
            (entry (% (heading))
                   (para (code "GL_SAMPLE_COVERAGE") " flag "))
            (entry (% (heading))
                   (para (code "GL_SAMPLE_COVERAGE_VALUE")
                         " value "))
            (entry (% (heading))
                   (para (code "GL_SAMPLE_COVERAGE_INVERT")
                         " value "))
            (entry (% (heading (code "GL_PIXEL_MODE_BIT")))
                   (para (code "GL_RED_BIAS")
                         " and "
                         (code "GL_RED_SCALE")
                         " settings "))
            (entry (% (heading))
                   (para (code "GL_GREEN_BIAS")
                         " and "
                         (code "GL_GREEN_SCALE")
                         " values "))
            (entry (% (heading))
                   (para (code "GL_BLUE_BIAS")
                         " and "
                         (code "GL_BLUE_SCALE")))
            (entry (% (heading))
                   (para (code "GL_ALPHA_BIAS")
                         " and "
                         (code "GL_ALPHA_SCALE")))
            (entry (% (heading))
                   (para (code "GL_DEPTH_BIAS")
                         " and "
                         (code "GL_DEPTH_SCALE")))
            (entry (% (heading))
                   (para (code "GL_INDEX_OFFSET")
                         " and "
                         (code "GL_INDEX_SHIFT")
                         " values "))
            (entry (% (heading))
                   (para (code "GL_MAP_COLOR")
                         " and "
                         (code "GL_MAP_STENCIL")
                         " flags "))
            (entry (% (heading))
                   (para (code "GL_ZOOM_X")
                         " and "
                         (code "GL_ZOOM_Y")
                         " factors "))
            (entry (% (heading))
                   (para (code "GL_READ_BUFFER") " setting "))
            (entry (% (heading (code "GL_POINT_BIT")))
                   (para (code "GL_POINT_SMOOTH") " flag "))
            (entry (% (heading)) (para "
Point size "))
            (entry (% (heading (code "GL_POLYGON_BIT")))
                   (para (code "GL_CULL_FACE") " enable bit "))
            (entry (% (heading))
                   (para (code "GL_CULL_FACE_MODE") " value "))
            (entry (% (heading))
                   (para (code "GL_FRONT_FACE") " indicator "))
            (entry (% (heading))
                   (para (code "GL_POLYGON_MODE") " setting "))
            (entry (% (heading))
                   (para (code "GL_POLYGON_SMOOTH") " flag "))
            (entry (% (heading))
                   (para (code "GL_POLYGON_STIPPLE") " enable bit "))
            (entry (% (heading))
                   (para (code "GL_POLYGON_OFFSET_FILL") " flag "))
            (entry (% (heading))
                   (para (code "GL_POLYGON_OFFSET_LINE") " flag "))
            (entry (% (heading))
                   (para (code "GL_POLYGON_OFFSET_POINT") " flag "))
            (entry (% (heading))
                   (para (code "GL_POLYGON_OFFSET_FACTOR")))
            (entry (% (heading))
                   (para (code "GL_POLYGON_OFFSET_UNITS")))
            (entry (% (heading (code "GL_POLYGON_STIPPLE_BIT")))
                   (para "
Polygon stipple image "))
            (entry (% (heading (code "GL_SCISSOR_BIT")))
                   (para (code "GL_SCISSOR_TEST") " flag "))
            (entry (% (heading)) (para "
Scissor box "))
            (entry (% (heading (code "GL_STENCIL_BUFFER_BIT")))
                   (para (code "GL_STENCIL_TEST") " enable bit "))
            (entry (% (heading))
                   (para "
Stencil function and reference value "))
            (entry (% (heading))
                   (para "
Stencil value mask "))
            (entry (% (heading))
                   (para "
Stencil fail, pass, and depth buffer pass actions "))
            (entry (% (heading))
                   (para "
Stencil buffer clear value "))
            (entry (% (heading))
                   (para "
Stencil buffer writemask "))
            (entry (% (heading (code "GL_TEXTURE_BIT")))
                   (para "
Enable bits for the four texture coordinates "))
            (entry (% (heading))
                   (para "
Border color for each texture image "))
            (entry (% (heading))
                   (para "
Minification function for each texture image "))
            (entry (% (heading))
                   (para "
Magnification function for each texture image "))
            (entry (% (heading))
                   (para "
Texture coordinates and wrap mode for each texture image "))
            (entry (% (heading))
                   (para "
Color and mode for each texture environment "))
            (entry (% (heading))
                   (para "
Enable bits "
                         (code "GL_TEXTURE_GEN_")
                         (var "x")
                         ", "
                         (var "x")
                         " is S, T, R, and Q "))
            (entry (% (heading))
                   (para (code "GL_TEXTURE_GEN_MODE")
                         " setting for S, T, R, and Q "))
            (entry (% (heading))
                   (para (code "glTexGen")
                         " plane equations for S, T, R, and Q "))
            (entry (% (heading))
                   (para "
Current texture bindings (for example, "
                         (code "GL_TEXTURE_BINDING_2D")
                         ") "))
            (entry (% (heading (code "GL_TRANSFORM_BIT")))
                   (para "
Coefficients of the six clipping planes "))
            (entry (% (heading))
                   (para "
Enable bits for the user-definable clipping planes "))
            (entry (% (heading))
                   (para (code "GL_MATRIX_MODE") " value "))
            (entry (% (heading))
                   (para (code "GL_NORMALIZE") " flag "))
            (entry (% (heading))
                   (para (code "GL_RESCALE_NORMAL") " flag "))
            (entry (% (heading (code "GL_VIEWPORT_BIT")))
                   (para "
Depth range (near and far) "))
            (entry (% (heading))
                   (para "
Viewport origin and extent ")))
     (para (code "glPopAttrib")
           " restores the values of the state variables saved with the last "
           (code "glPushAttrib")
           " command.
            Those not saved are left unchanged. ")
     (para "
It is an error to push attributes onto a full stack
            or to pop attributes off an empty stack.
            In either case, the error flag is set
            and no other change is made to GL state. ")
     (para "
Initially, the attribute stack is empty. ")
     (heading "Errors")
     (para (code "GL_STACK_OVERFLOW")
           " is generated if "
           (code "glPushAttrib")
           " is called while
            the attribute stack is full. ")
     (para (code "GL_STACK_UNDERFLOW")
           " is generated if "
           (code "glPopAttrib")
           " is called while
            the attribute stack is empty. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glPushAttrib")
           " or "
           (code "glPopAttrib")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glPushClientAttrib
  "glPushClientAttrib"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glPushClientAttrib"))
      (paramdef "GLbitfield " (parameter "mask"))))
  '(*fragment*
     (heading
       "push and pop the client attribute stack")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "mask")))
                   (para "
Specifies a mask that indicates which attributes to save.  Values for "
                         (var "mask")
                         " are listed below. ")))
     (heading "Description")
     (para (code "glPushClientAttrib")
           " takes one argument,
            a mask that indicates which groups of client-state variables
            to save on the client attribute stack.
            Symbolic constants are used to set bits in the mask. "
           (var "mask")
           "
is typically constructed by specifying the bitwise-or of several 
\t    of these constants together.
            The special mask "
           (code "GL_CLIENT_ALL_ATTRIB_BITS")
           "
can be used to save all stackable client state. ")
     (para "
The symbolic mask constants and their associated GL client state are as follows
            (the second column lists which attributes are saved): ")
     (para (code "GL_CLIENT_PIXEL_STORE_BIT")
           "\tPixel storage modes "
           (code "GL_CLIENT_VERTEX_ARRAY_BIT")
           "\tVertex arrays (and enables) ")
     (para (code "glPopClientAttrib")
           " restores the values of the client-state variables
            saved with the last "
           (code "glPushClientAttrib")
           ".
            Those not saved are left unchanged. ")
     (para "
It is an error to push attributes onto a full client attribute stack
            or to pop attributes off an empty stack.
            In either case, the error flag is set,
            and no other change is made to GL state. ")
     (para "
Initially, the client attribute stack is empty. ")
     (heading "Errors")
     (para (code "GL_STACK_OVERFLOW")
           " is generated if "
           (code "glPushClientAttrib")
           " is called while
            the attribute stack is full. ")
     (para (code "GL_STACK_UNDERFLOW")
           " is generated if "
           (code "glPopClientAttrib")
           " is called while
            the attribute stack is empty. ")))

(define-gl-procedure
  glPushMatrix
  "glPushMatrix"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glPushMatrix"))
      (paramdef (parameter "void"))))
  '(*fragment*
     (heading "push and pop the current matrix stack")
     (heading "Description")
     (para "
There is a stack of matrices for each of the matrix modes.
            In "
           (code "GL_MODELVIEW")
           " mode,
            the stack depth is at least 32.
            In the other modes, "
           (code "GL_COLOR")
           ", "
           (code "GL_PROJECTION")
           ", and "
           (code "GL_TEXTURE")
           ",
            the depth is at least 2.
            The current matrix in any mode is the matrix on the top of the stack
            for that mode. ")
     (para (code "glPushMatrix")
           " pushes the current matrix stack down by one,
            duplicating the current matrix.
            That is,
            after a "
           (code "glPushMatrix")
           " call,
            the matrix on top of the stack is identical to the one below it. ")
     (para (code "glPopMatrix")
           " pops the current matrix stack,
            replacing the current matrix with the one below it on the stack. ")
     (para "
Initially, each of the stacks contains one matrix, an identity matrix. ")
     (para "
It is an error to push a full matrix stack
            or to pop a matrix stack that contains only a single matrix.
            In either case, the error flag is set
            and no other change is made to GL state. ")
     (heading "Errors")
     (para (code "GL_STACK_OVERFLOW")
           " is generated if "
           (code "glPushMatrix")
           " is called while
            the current matrix stack is full. ")
     (para (code "GL_STACK_UNDERFLOW")
           " is generated if "
           (code "glPopMatrix")
           " is called while
            the current matrix stack contains only a single matrix. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glPushMatrix")
           " or "
           (code "glPopMatrix")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glPushName
  "glPushName"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glPushName"))
      (paramdef "GLuint " (parameter "name"))))
  '(*fragment*
     (heading "push and pop the name stack")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "name")))
                   (para "
Specifies a name that will be pushed onto the name stack. ")))
     (heading "Description")
     (para "
The name stack is used during selection mode to allow sets of rendering
            commands to be uniquely identified.
            It consists of an ordered set of unsigned integers and is initially empty. ")
     (para (code "glPushName")
           " causes "
           (var "name")
           " to be pushed onto the name stack. "
           (code "glPopName")
           " pops one name off the top of the stack. ")
     (para "
The maximum name stack depth is implementation-dependent; call "
           (code "GL_MAX_NAME_STACK_DEPTH")
           " to find out the value for a particular
            implementation. It is an
            error to push a name onto a full stack
            or to pop a name off an empty stack.
            It is also an error to manipulate the name stack between the execution of "
           (code "glBegin")
           " and the corresponding execution of "
           (code "glEnd")
           ".
            In any of these cases, the error flag is set and no other change is
            made to GL state. ")
     (para "
The name stack is always empty while the render mode is not "
           (code "GL_SELECT")
           ".
            Calls to "
           (code "glPushName")
           " or "
           (code "glPopName")
           " while the render mode is not "
           (code "GL_SELECT")
           " are ignored. ")
     (heading "Errors")
     (para (code "GL_STACK_OVERFLOW")
           " is generated if "
           (code "glPushName")
           " is called while the
            name stack is full. ")
     (para (code "GL_STACK_UNDERFLOW")
           " is generated if "
           (code "glPopName")
           " is called while the
            name stack is empty. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glPushName")
           " or "
           (code "glPopName")
           "
is executed between a call to "
           (code "glBegin")
           " and the corresponding call to "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glRasterPos
  "glRasterPos"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glRasterPos2s"))
      (paramdef "GLshort " (parameter "x"))
      (paramdef "GLshort " (parameter "y"))))
  '(*fragment*
     (heading
       "specify the raster position for pixel operations")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "x")))
                   (itemx (var "y"))
                   (itemx (var "z"))
                   (itemx (var "w"))
                   (para "
Specify the "
                         (math (var "x"))
                         ", "
                         (math (var "y"))
                         ", "
                         (math (var "z"))
                         ",
                    and "
                         (math (var "w"))
                         "
object coordinates
                    (if present)
                    for the raster
                    position. ")))
     (heading "Description")
     (para "
The GL maintains a 3D position in window coordinates.
            This position,
            called the raster position,
            is used to position pixel and bitmap write operations. It is
            maintained with subpixel accuracy.
            See "
           (code "glBitmap")
           ", "
           (code "glDrawPixels")
           ", and "
           (code "glCopyPixels")
           ". ")
     (para "
The current raster position consists of three window coordinates
            ("
           (math (var "x"))
           ", "
           (math (var "y"))
           ", "
           (math (var "z"))
           "),
            a clip coordinate value 
            ("
           (math (var "w"))
           "),
            an eye coordinate distance,
            a valid bit,
            and associated color data and texture coordinates.
            The "
           (math (var "w"))
           "
coordinate is a clip coordinate,
            because "
           (math (var "w"))
           "
is not projected to window coordinates. "
           (code "glRasterPos4")
           " specifies object coordinates "
           (math (var "x"))
           ", "
           (math (var "y"))
           ", "
           (math (var "z"))
           ",
            and "
           (math (var "w"))
           "
explicitly. "
           (code "glRasterPos3")
           " specifies object coordinate "
           (math (var "x"))
           ", "
           (math (var "y"))
           ",
            and "
           (math (var "z"))
           "
explicitly,
            while "
           (math (var "w"))
           "
is implicitly set to 1. "
           (code "glRasterPos2")
           " uses the argument values for "
           (math (var "x"))
           "
and "
           (math (var "y"))
           "
while
            implicitly setting "
           (math (var "z"))
           "
and "
           (math (var "w"))
           "
to 0 and 1. ")
     (para "
The object coordinates presented by "
           (code "glRasterPos")
           " are treated just like those
            of a "
           (code "glVertex")
           " command:
            They are transformed by the current modelview and projection matrices
            and passed to the clipping stage.
            If the vertex is not culled,
            then it is projected and scaled to window coordinates,
            which become the new current raster position,
            and the "
           (code "GL_CURRENT_RASTER_POSITION_VALID")
           " flag is set.
            If the vertex "
           (var "is")
           "
culled,
            then the valid bit is cleared and the current raster position
            and associated color and texture coordinates are undefined. ")
     (para "
The current raster position also includes some associated color data
            and texture coordinates.
            If lighting is enabled,
            then "
           (code "GL_CURRENT_RASTER_COLOR")
           "
(in RGBA mode)
            or "
           (code "GL_CURRENT_RASTER_INDEX")
           "
(in color index mode)
            is set to the color produced by the lighting calculation
            (see "
           (code "glLight")
           ", "
           (code "glLightModel")
           ", and "
           (code "glShadeModel")
           ").
            If lighting is disabled,
            current color
            (in RGBA mode, state variable "
           (code "GL_CURRENT_COLOR")
           ")
            or color index
            (in color index mode, state variable "
           (code "GL_CURRENT_INDEX")
           ")
            is used to update the current raster color. "
           (code "GL_CURRENT_RASTER_SECONDARY_COLOR")
           " (in RGBA mode) is likewise updated. ")
     (para "
Likewise, "
           (code "GL_CURRENT_RASTER_TEXTURE_COORDS")
           " is updated as a function
            of "
           (code "GL_CURRENT_TEXTURE_COORDS")
           ",
            based on the texture matrix and the texture generation functions
            (see "
           (code "glTexGen")
           ").
            Finally,
            the distance from the origin of the eye coordinate system to the
            vertex as transformed by only the modelview matrix replaces "
           (code "GL_CURRENT_RASTER_DISTANCE")
           ". ")
     (para "
Initially, the current raster position is (0, 0, 0, 1),
            the current raster distance is 0,
            the valid bit is set,
            the associated RGBA color is (1, 1, 1, 1),
            the associated color index is 1,
            and the associated texture coordinates are (0, 0, 0, 1).
            In RGBA mode, "
           (code "GL_CURRENT_RASTER_INDEX")
           " is always 1;
            in color index mode,
            the current raster RGBA color always maintains its initial value. ")
     (heading "Errors")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glRasterPos")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glReadBuffer
  "glReadBuffer"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glReadBuffer"))
      (paramdef "GLenum " (parameter "mode"))))
  '(*fragment*
     (heading
       "select a color buffer source for pixels")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "mode")))
                   (para "
Specifies a color buffer.
                    Accepted values are "
                         (code "GL_FRONT_LEFT")
                         ", "
                         (code "GL_FRONT_RIGHT")
                         ", "
                         (code "GL_BACK_LEFT")
                         ", "
                         (code "GL_BACK_RIGHT")
                         ", "
                         (code "GL_FRONT")
                         ", "
                         (code "GL_BACK")
                         ", "
                         (code "GL_LEFT")
                         ", "
                         (code "GL_RIGHT")
                         ", and "
                         (code "GL_AUX")
                         (var "i")
                         ",
                    where "
                         (var "i")
                         " is between 0 and the value of "
                         (code "GL_AUX_BUFFERS")
                         " minus 1. ")))
     (heading "Description")
     (para (code "glReadBuffer")
           " specifies a color buffer as the source for subsequent "
           (code "glReadPixels")
           ", "
           (code "glCopyTexImage1D")
           ", "
           (code "glCopyTexImage2D")
           ", "
           (code "glCopyTexSubImage1D")
           ", "
           (code "glCopyTexSubImage2D")
           ", "
           (code "glCopyTexSubImage3D")
           ", and "
           (code "glCopyPixels")
           " commands. "
           (var "mode")
           " accepts one of twelve or more predefined values.
            ("
           (code "GL_AUX0")
           " through "
           (code "GL_AUX3")
           " are always defined.)
            In a fully configured system, "
           (code "GL_FRONT")
           ", "
           (code "GL_LEFT")
           ", and "
           (code "GL_FRONT_LEFT")
           " all name the front left buffer, "
           (code "GL_FRONT_RIGHT")
           " and "
           (code "GL_RIGHT")
           " name the front right buffer, and "
           (code "GL_BACK_LEFT")
           " and "
           (code "GL_BACK")
           " name the back left buffer. ")
     (para "
Nonstereo double-buffered configurations have only a front left and a
            back left buffer.
            Single-buffered configurations have a front left and a front right
            buffer if stereo, and only a front left buffer if nonstereo.
            It is an error to specify a nonexistent buffer to "
           (code "glReadBuffer")
           ". ")
     (para (var "mode")
           " is initially "
           (code "GL_FRONT")
           " in single-buffered configurations
            and "
           (code "GL_BACK")
           " in double-buffered configurations. ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "mode")
           " is not one of the twelve
            (or more) accepted values. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (var "mode")
           " specifies a buffer
            that does not exist. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glReadBuffer")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glReadPixels
  "glReadPixels"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glReadPixels"))
      (paramdef "GLint " (parameter "x"))
      (paramdef "GLint " (parameter "y"))
      (paramdef "GLsizei " (parameter "width"))
      (paramdef "GLsizei " (parameter "height"))
      (paramdef "GLenum " (parameter "format"))
      (paramdef "GLenum " (parameter "type"))
      (paramdef "GLvoid * " (parameter "data"))))
  '(*fragment*
     (heading
       "read a block of pixels from the frame buffer")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "x")))
                   (itemx (var "y"))
                   (para "
Specify the window coordinates of the first pixel
                    that is read from the frame buffer.
                    This location is the lower left corner of a rectangular block of pixels. "))
            (entry (% (heading (var "width")))
                   (itemx (var "height"))
                   (para "
Specify the dimensions of the pixel rectangle. "
                         (var "width")
                         " and "
                         (var "height")
                         " of one correspond to a single pixel. "))
            (entry (% (heading (var "format")))
                   (para "
Specifies the format of the pixel data.
                    The following symbolic values are accepted: "
                         (code "GL_COLOR_INDEX")
                         ", "
                         (code "GL_STENCIL_INDEX")
                         ", "
                         (code "GL_DEPTH_COMPONENT")
                         ", "
                         (code "GL_RED")
                         ", "
                         (code "GL_GREEN")
                         ", "
                         (code "GL_BLUE")
                         ", "
                         (code "GL_ALPHA")
                         ", "
                         (code "GL_RGB")
                         ", "
                         (code "GL_BGR")
                         ", "
                         (code "GL_RGBA")
                         ", "
                         (code "GL_BGRA")
                         ", "
                         (code "GL_LUMINANCE")
                         ", and "
                         (code "GL_LUMINANCE_ALPHA")
                         ". "))
            (entry (% (heading (var "type")))
                   (para "
Specifies the data type of the pixel data.
                    Must be one of "
                         (code "GL_UNSIGNED_BYTE")
                         ", "
                         (code "GL_BYTE")
                         ", "
                         (code "GL_BITMAP")
                         ", "
                         (code "GL_UNSIGNED_SHORT")
                         ", "
                         (code "GL_SHORT")
                         ", "
                         (code "GL_UNSIGNED_INT")
                         ", "
                         (code "GL_INT")
                         ", "
                         (code "GL_FLOAT")
                         ", "
                         (code "GL_UNSIGNED_BYTE_3_3_2")
                         ", "
                         (code "GL_UNSIGNED_BYTE_2_3_3_REV")
                         ", "
                         (code "GL_UNSIGNED_SHORT_5_6_5")
                         ", "
                         (code "GL_UNSIGNED_SHORT_5_6_5_REV")
                         ", "
                         (code "GL_UNSIGNED_SHORT_4_4_4_4")
                         ", "
                         (code "GL_UNSIGNED_SHORT_4_4_4_4_REV")
                         ", "
                         (code "GL_UNSIGNED_SHORT_5_5_5_1")
                         ", "
                         (code "GL_UNSIGNED_SHORT_1_5_5_5_REV")
                         ", "
                         (code "GL_UNSIGNED_INT_8_8_8_8")
                         ", "
                         (code "GL_UNSIGNED_INT_8_8_8_8_REV")
                         ", "
                         (code "GL_UNSIGNED_INT_10_10_10_2")
                         ", or "
                         (code "GL_UNSIGNED_INT_2_10_10_10_REV")
                         ". "))
            (entry (% (heading (var "data")))
                   (para "
Returns the pixel data. ")))
     (heading "Description")
     (para (code "glReadPixels")
           " returns pixel data from the frame buffer,
            starting with the pixel whose lower left corner
            is at location ("
           (var "x")
           ", "
           (var "y")
           "),
            into client memory starting at location "
           (var "data")
           ".
            Several parameters control the processing of the pixel data before
            it is placed into client memory.
            These parameters are set with three commands: "
           (code "glPixelStore")
           ", "
           (code "glPixelTransfer")
           ", and "
           (code "glPixelMap")
           ".
            This reference page describes the effects on "
           (code "glReadPixels")
           " of most,
            but not all of the parameters specified by these three commands. ")
     (para "
If a non-zero named buffer object is bound to the "
           (code "GL_PIXEL_PACK_BUFFER")
           " target 
            (see "
           (code "glBindBuffer")
           ") while a block of pixels is
            requested, "
           (var "data")
           " is treated as a byte offset into the buffer object's data store
            rather than a pointer to client memory. ")
     (para "
When the "
           (code "ARB_imaging")
           " extension is supported, the pixel data may
            be processed by additional operations including color table lookup,
            color matrix transformations, convolutions, histograms, and minimum and
            maximum pixel value computations. ")
     (para (code "glReadPixels")
           " returns values from each pixel with lower left corner at "
           (math "("
                 (var "x")
                 "+"
                 (var "i")
                 ","
                 (var "y")
                 "+"
                 (var "j")
                 ")")
           "
for "
           (math "0" "<=" (var "i") "<" (var "width"))
           "
and "
           (math "0" "<=" (var "j") "<" (var "height"))
           ".
            This pixel is said to be the "
           (math (var "i"))
           "th
            pixel in the "
           (math (var "j"))
           "th
            row.
            Pixels are returned in row order from the lowest to the highest row,
            left to right in each row. ")
     (para (var "format")
           " specifies the format for the returned pixel values;
            accepted values are: ")
     (table (% (formatter (asis)))
            (entry (% (heading (code "GL_COLOR_INDEX")))
                   (para "
Color indices are read from the color buffer
                        selected by "
                         (code "glReadBuffer")
                         ".
                        Each index is converted to fixed point,
                        shifted left or right depending on the value and sign of "
                         (code "GL_INDEX_SHIFT")
                         ",
                        and added to "
                         (code "GL_INDEX_OFFSET")
                         ".
                        If "
                         (code "GL_MAP_COLOR")
                         " is "
                         (code "GL_TRUE")
                         ",
                        indices are replaced by their mappings in the table "
                         (code "GL_PIXEL_MAP_I_TO_I")
                         ". "))
            (entry (% (heading (code "GL_STENCIL_INDEX")))
                   (para "
Stencil values are read from the stencil buffer.
                        Each index is converted to fixed point,
                        shifted left or right depending on the value and sign of "
                         (code "GL_INDEX_SHIFT")
                         ",
                        and added to "
                         (code "GL_INDEX_OFFSET")
                         ".
                        If "
                         (code "GL_MAP_STENCIL")
                         " is "
                         (code "GL_TRUE")
                         ",
                        indices are replaced by their mappings in the table "
                         (code "GL_PIXEL_MAP_S_TO_S")
                         ". "))
            (entry (% (heading (code "GL_DEPTH_COMPONENT")))
                   (para "
Depth values are read from the depth buffer.
                        Each component is converted to floating point such that the minimum depth
                        value maps to 0 and the maximum value maps to 1.
                        Each component is then multiplied by "
                         (code "GL_DEPTH_SCALE")
                         ",
                        added to "
                         (code "GL_DEPTH_BIAS")
                         ",
                        and finally clamped to the range "
                         (math "[" "0" "," "1" "]")
                         ". "))
            (entry (% (heading (code "GL_RED"))))
            (entry (% (heading (code "GL_GREEN"))))
            (entry (% (heading (code "GL_BLUE"))))
            (entry (% (heading (code "GL_ALPHA"))))
            (entry (% (heading (code "GL_RGB"))))
            (entry (% (heading (code "GL_BGR"))))
            (entry (% (heading (code "GL_RGBA"))))
            (entry (% (heading (code "GL_BGRA"))))
            (entry (% (heading (code "GL_LUMINANCE"))))
            (entry (% (heading (code "GL_LUMINANCE_ALPHA")))
                   (para "
Processing differs depending on whether color buffers store color indices
                        or RGBA color components.
                        If color indices are stored,
                        they are read from the color buffer selected by "
                         (code "glReadBuffer")
                         ".
                        Each index is converted to fixed point,
                        shifted left or right depending on the value and sign of "
                         (code "GL_INDEX_SHIFT")
                         ",
                        and added to "
                         (code "GL_INDEX_OFFSET")
                         ".
                        Indices are then replaced by the red,
                        green,
                        blue,
                        and alpha values obtained by indexing the tables "
                         (code "GL_PIXEL_MAP_I_TO_R")
                         ", "
                         (code "GL_PIXEL_MAP_I_TO_G")
                         ", "
                         (code "GL_PIXEL_MAP_I_TO_B")
                         ", and "
                         (code "GL_PIXEL_MAP_I_TO_A")
                         ".
                        Each table must be of size "
                         (math "2" "^" (var "n"))
                         ",
                        but "
                         (math (var "n"))
                         "
may be different for
                        different tables.
                        Before an index is used to look up a value in a table of
                        size "
                         (math "2" "^" (var "n"))
                         ",
                        it must be masked against "
                         (math "2" "^" (var "n") "-" "1")
                         ". ")
                   (para "
If RGBA color components are stored in the color buffers,
                        they are read from the color buffer selected by "
                         (code "glReadBuffer")
                         ".
                        Each color component is converted to floating point such that zero intensity
                        maps to 0.0 and full intensity maps to 1.0.
                        Each component is then multiplied by "
                         (code "GL_c_SCALE")
                         " and
                        added to "
                         (code "GL_c_BIAS")
                         ",
                        where "
                         (var "c")
                         " is RED, GREEN, BLUE, or ALPHA.
                        Finally,
                        if "
                         (code "GL_MAP_COLOR")
                         " is "
                         (code "GL_TRUE")
                         ",
                        each component is clamped to the range "
                         (math "[" "0" "," "1" "]")
                         ",
                        scaled to the size of its corresponding table, and is then
                        replaced by its mapping in the table "
                         (code "GL_PIXEL_MAP_c_TO_c")
                         ",
                        where "
                         (var "c")
                         " is R, G, B, or A. ")
                   (para "
Unneeded data is then discarded.
                        For example, "
                         (code "GL_RED")
                         " discards the green, blue, and alpha components,
                        while "
                         (code "GL_RGB")
                         " discards only the alpha component. "
                         (code "GL_LUMINANCE")
                         " computes a single-component value as the sum of
                        the red,
                        green,
                        and blue components,
                        and "
                         (code "GL_LUMINANCE_ALPHA")
                         " does the same,
                        while keeping alpha as a second value.
                        The final values are clamped to the range "
                         (math "[" "0" "," "1" "]")
                         ". ")))
     (para "
The shift,
            scale,
            bias,
            and lookup factors just described are all specified by "
           (code "glPixelTransfer")
           ".
            The lookup table contents themselves are specified by "
           (code "glPixelMap")
           ". ")
     (para "
Finally, the indices or components
            are converted to the proper format,
            as specified by "
           (var "type")
           ".
            If "
           (var "format")
           " is "
           (code "GL_COLOR_INDEX")
           " or "
           (code "GL_STENCIL_INDEX")
           "
and "
           (var "type")
           " is not "
           (code "GL_FLOAT")
           ",
            each index is masked with the mask value given in the following table.
            If "
           (var "type")
           " is "
           (code "GL_FLOAT")
           ", then each integer index is converted to
            single-precision floating-point format. ")
     (para "
If "
           (var "format")
           " is "
           (code "GL_RED")
           ", "
           (code "GL_GREEN")
           ", "
           (code "GL_BLUE")
           ", "
           (code "GL_ALPHA")
           ", "
           (code "GL_RGB")
           ", "
           (code "GL_BGR")
           ", "
           (code "GL_RGBA")
           ", "
           (code "GL_BGRA")
           ", "
           (code "GL_LUMINANCE")
           ", or "
           (code "GL_LUMINANCE_ALPHA")
           " and "
           (var "type")
           " is not "
           (code "GL_FLOAT")
           ",
            each component is multiplied by the multiplier shown in the following table.
            If type is "
           (code "GL_FLOAT")
           ", then each component is passed as is
            (or converted to the client's single-precision floating-point format if
            it is different from the one used by the GL). ")
     (para)
     (table (% (formatter (asis)))
            (entry (% (heading (var "type")))
                   (para (strong "Index Mask")
                         ", "
                         (strong "Component Conversion")))
            (entry (% (heading (code "GL_UNSIGNED_BYTE")))
                   (para (math "2" "^" "8" "-" "1")
                         ", "
                         (math "("
                               "2"
                               "^"
                               "8"
                               "-"
                               "1"
                               ","
                               ")"
                               "\u2062"
                               (var "c"))))
            (entry (% (heading (code "GL_BYTE")))
                   (para (math "2" "^" "7" "-" "1")
                         ", "
                         (math "("
                               "2"
                               "^"
                               "8"
                               "-"
                               "1"
                               ","
                               ")"
                               "\u2062"
                               (var "c")
                               "-"
                               "1"
                               ","
                               "/"
                               "2")))
            (entry (% (heading (code "GL_BITMAP")))
                   (para (math "1") ", " (math "1")))
            (entry (% (heading (code "GL_UNSIGNED_SHORT")))
                   (para (math "2" "^" "16" "-" "1")
                         ", "
                         (math "("
                               "2"
                               "^"
                               "16"
                               "-"
                               "1"
                               ","
                               ")"
                               "\u2062"
                               (var "c"))))
            (entry (% (heading (code "GL_SHORT")))
                   (para (math "2" "^" "15" "-" "1")
                         ", "
                         (math "("
                               "2"
                               "^"
                               "16"
                               "-"
                               "1"
                               ","
                               ")"
                               "\u2062"
                               (var "c")
                               "-"
                               "1"
                               ","
                               "/"
                               "2")))
            (entry (% (heading (code "GL_UNSIGNED_INT")))
                   (para (math "2" "^" "32" "-" "1")
                         ", "
                         (math "("
                               "2"
                               "^"
                               "32"
                               "-"
                               "1"
                               ","
                               ")"
                               "\u2062"
                               (var "c"))))
            (entry (% (heading (code "GL_INT")))
                   (para (math "2" "^" "31" "-" "1")
                         ", "
                         (math "("
                               "2"
                               "^"
                               "32"
                               "-"
                               "1"
                               ","
                               ")"
                               "\u2062"
                               (var "c")
                               "-"
                               "1"
                               ","
                               "/"
                               "2")))
            (entry (% (heading (code "GL_FLOAT")))
                   (para "
none " ", " (math (var "c")))))
     (para "
Return values are placed in memory as follows.
            If "
           (var "format")
           " is "
           (code "GL_COLOR_INDEX")
           ", "
           (code "GL_STENCIL_INDEX")
           ", "
           (code "GL_DEPTH_COMPONENT")
           ", "
           (code "GL_RED")
           ", "
           (code "GL_GREEN")
           ", "
           (code "GL_BLUE")
           ", "
           (code "GL_ALPHA")
           ", or "
           (code "GL_LUMINANCE")
           ",
            a single value is returned and the data for the "
           (math (var "i"))
           "th
            pixel in the "
           (math (var "j"))
           "th
            row
            is placed in location "
           (math "("
                 (var "j")
                 ","
                 ")"
                 "\u2062"
                 (var "width")
                 "+"
                 (var "i"))
           ". "
           (code "GL_RGB")
           " and "
           (code "GL_BGR")
           " return three values, "
           (code "GL_RGBA")
           " and "
           (code "GL_BGRA")
           " return four values,
            and "
           (code "GL_LUMINANCE_ALPHA")
           " returns two values for each pixel,
            with all values corresponding to a single pixel occupying contiguous space
            in "
           (var "data")
           ".
            Storage parameters set by "
           (code "glPixelStore")
           ",
            such as "
           (code "GL_PACK_LSB_FIRST")
           " and "
           (code "GL_PACK_SWAP_BYTES")
           ",
            affect the way that data is written into memory.
            See "
           (code "glPixelStore")
           " for a description. ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "format")
           " or "
           (var "type")
           " is not an
            accepted value. ")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "type")
           " is "
           (code "GL_BITMAP")
           " and "
           (var "format")
           " is
            not "
           (code "GL_COLOR_INDEX")
           " or "
           (code "GL_STENCIL_INDEX")
           ". ")
     (para (code "GL_INVALID_VALUE")
           " is generated if either "
           (var "width")
           " or "
           (var "height")
           " is negative. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (var "format")
           " is "
           (code "GL_COLOR_INDEX")
           "
and the color buffers store RGBA color components. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (var "format")
           " is "
           (code "GL_STENCIL_INDEX")
           "
and there is no stencil buffer. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (var "format")
           " is "
           (code "GL_DEPTH_COMPONENT")
           "
and there is no depth buffer. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (var "type")
           " is one of "
           (code "GL_UNSIGNED_BYTE_3_3_2")
           ", "
           (code "GL_UNSIGNED_BYTE_2_3_3_REV")
           ", "
           (code "GL_UNSIGNED_SHORT_5_6_5")
           ", or "
           (code "GL_UNSIGNED_SHORT_5_6_5_REV")
           "
and "
           (var "format")
           " is not "
           (code "GL_RGB")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (var "type")
           " is one of "
           (code "GL_UNSIGNED_SHORT_4_4_4_4")
           ", "
           (code "GL_UNSIGNED_SHORT_4_4_4_4_REV")
           ", "
           (code "GL_UNSIGNED_SHORT_5_5_5_1")
           ", "
           (code "GL_UNSIGNED_SHORT_1_5_5_5_REV")
           ", "
           (code "GL_UNSIGNED_INT_8_8_8_8")
           ", "
           (code "GL_UNSIGNED_INT_8_8_8_8_REV")
           ", "
           (code "GL_UNSIGNED_INT_10_10_10_2")
           ", or "
           (code "GL_UNSIGNED_INT_2_10_10_10_REV")
           "
and "
           (var "format")
           " is neither "
           (code "GL_RGBA")
           " nor "
           (code "GL_BGRA")
           ". ")
     (para "
The formats "
           (code "GL_BGR")
           ", and "
           (code "GL_BGRA")
           " and types "
           (code "GL_UNSIGNED_BYTE_3_3_2")
           ", "
           (code "GL_UNSIGNED_BYTE_2_3_3_REV")
           ", "
           (code "GL_UNSIGNED_SHORT_5_6_5")
           ", "
           (code "GL_UNSIGNED_SHORT_5_6_5_REV")
           ", "
           (code "GL_UNSIGNED_SHORT_4_4_4_4")
           ", "
           (code "GL_UNSIGNED_SHORT_4_4_4_4_REV")
           ", "
           (code "GL_UNSIGNED_SHORT_5_5_5_1")
           ", "
           (code "GL_UNSIGNED_SHORT_1_5_5_5_REV")
           ", "
           (code "GL_UNSIGNED_INT_8_8_8_8")
           ", "
           (code "GL_UNSIGNED_INT_8_8_8_8_REV")
           ", "
           (code "GL_UNSIGNED_INT_10_10_10_2")
           ", and "
           (code "GL_UNSIGNED_INT_2_10_10_10_REV")
           " are available only if the GL version
            is 1.2 or greater. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_PACK_BUFFER")
           " target and the buffer object's data store is currently mapped. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_PACK_BUFFER")
           " target and the data would be packed to the buffer 
            object such that the memory writes required would exceed the data store size. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_PACK_BUFFER")
           " target and "
           (var "data")
           " is not evenly divisible 
            into the number of bytes needed to store in memory a datum indicated by "
           (var "type")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glReadPixels")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glRect
  "glRect"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glRectd"))
      (paramdef "GLdouble " (parameter "x1"))
      (paramdef "GLdouble " (parameter "y1"))
      (paramdef "GLdouble " (parameter "x2"))
      (paramdef "GLdouble " (parameter "y2"))))
  '(*fragment*
     (heading "draw a rectangle")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "x1")))
                   (itemx (var "y1"))
                   (para "
Specify one vertex of a rectangle. "))
            (entry (% (heading (var "x2")))
                   (itemx (var "y2"))
                   (para "
Specify the opposite vertex of the rectangle. ")))
     (heading "Description")
     (para (code "glRect")
           " supports efficient specification of rectangles as two corner points.
            Each
            rectangle command takes four arguments,
            organized either as two consecutive pairs of "
           (math "(" (var "x") "," (var "y") ")")
           "
coordinates
            or as two pointers to arrays,
            each containing an "
           (math "(" (var "x") "," (var "y") ")")
           "
pair.
            The resulting rectangle is defined in the "
           (math (var "z") "=" "0")
           "
plane. ")
     (para (code "glRect")
           "("
           (var "x1")
           ", "
           (var "y1")
           ", "
           (var "x2")
           ", "
           (var "y2")
           ")
            is exactly equivalent to the following sequence: "
           "
Note that if the second vertex is above and to the right of the first vertex,
            the rectangle is constructed with a counterclockwise winding. ")
     (example
       "
glBegin("
       (code "GL_POLYGON")
       ");
glVertex2("
       (var "x1")
       ", "
       (var "y1")
       ");
glVertex2("
       (var "x2")
       ", "
       (var "y1")
       ");
glVertex2("
       (var "x2")
       ", "
       (var "y2")
       ");
glVertex2("
       (var "x1")
       ", "
       (var "y2")
       ");
glEnd(); ")
     (heading "Errors")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glRect")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glRenderMode
  "glRenderMode"
  (funcsynopsis
    (funcprototype
      (funcdef "GLint " (function "glRenderMode"))
      (paramdef "GLenum " (parameter "mode"))))
  '(*fragment*
     (heading "set rasterization mode")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "mode")))
                   (para "
Specifies the rasterization mode.
                    Three values are accepted: "
                         (code "GL_RENDER")
                         ", "
                         (code "GL_SELECT")
                         ", and "
                         (code "GL_FEEDBACK")
                         ".
                    The initial value is "
                         (code "GL_RENDER")
                         ". ")))
     (heading "Description")
     (para (code "glRenderMode")
           " sets the rasterization mode.
            It takes one argument, "
           (var "mode")
           ",
            which can assume one of three predefined values: ")
     (table (% (formatter (asis)))
            (entry (% (heading (code "GL_RENDER")))
                   (para "
Render mode. Primitives are rasterized,
                        producing pixel fragments,
                        which are written into the frame buffer.
                        This is the normal mode
                        and also the default mode. "))
            (entry (% (heading (code "GL_SELECT")))
                   (para "
Selection mode.
                        No pixel fragments are produced,
                        and no change to the frame buffer contents is made.
                        Instead,
                        a record of the names of primitives that would have been drawn
                        if the render mode had been "
                         (code "GL_RENDER")
                         " is returned in a select buffer,
                        which must be created (see "
                         (code "glSelectBuffer")
                         ") before selection mode
                        is entered. "))
            (entry (% (heading (code "GL_FEEDBACK")))
                   (para "
Feedback mode.
                        No pixel fragments are produced,
                        and no change to the frame buffer contents is made.
                        Instead,
                        the coordinates and attributes of vertices that would have been drawn
                        if the render mode had been "
                         (code "GL_RENDER")
                         " is returned in a feedback buffer,
                        which must be created (see "
                         (code "glFeedbackBuffer")
                         ") before feedback mode
                        is entered. ")))
     (para "
The return value of "
           (code "glRenderMode")
           " is determined by the render mode at the time "
           (code "glRenderMode")
           " is called,
            rather than by "
           (var "mode")
           ".
            The values returned for the three render modes are as follows: ")
     (table (% (formatter (asis)))
            (entry (% (heading (code "GL_RENDER")))
                   (para "
0. "))
            (entry (% (heading (code "GL_SELECT")))
                   (para "
The number of hit records transferred to the select buffer. "))
            (entry (% (heading (code "GL_FEEDBACK")))
                   (para "
The number of values (not vertices) transferred to the feedback buffer. ")))
     (para "
See the "
           (code "glSelectBuffer")
           " and "
           (code "glFeedbackBuffer")
           " reference pages for
            more details concerning selection and feedback operation. ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "mode")
           " is not one of the three
            accepted values. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glSelectBuffer")
           " is called
            while the render mode is "
           (code "GL_SELECT")
           ",
            or if "
           (code "glRenderMode")
           " is called with argument "
           (code "GL_SELECT")
           " before "
           (code "glSelectBuffer")
           " is called at least once. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glFeedbackBuffer")
           " is called
            while the render mode is "
           (code "GL_FEEDBACK")
           ",
            or if "
           (code "glRenderMode")
           " is called with argument "
           (code "GL_FEEDBACK")
           " before "
           (code "glFeedbackBuffer")
           " is called at least once. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glRenderMode")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glResetHistogram
  "glResetHistogram"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glResetHistogram"))
      (paramdef "GLenum " (parameter "target"))))
  '(*fragment*
     (heading "reset histogram table entries to zero")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "target")))
                   (para "
Must be " (code "GL_HISTOGRAM") ". ")))
     (heading "Description")
     (para (code "glResetHistogram")
           " resets all the elements of the current histogram table to zero. ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "target")
           " is not "
           (code "GL_HISTOGRAM")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glResetHistogram")
           " is executed
            between the execution of "
           (code "glBegin")
           " and the corresponding
            execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glResetMinmax
  "glResetMinmax"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glResetMinmax"))
      (paramdef "GLenum " (parameter "target"))))
  '(*fragment*
     (heading
       "reset minmax table entries to initial values")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "target")))
                   (para "
Must be " (code "GL_MINMAX") ". ")))
     (heading "Description")
     (para (code "glResetMinmax")
           " resets the elements of the current minmax table to their
            initial values: the ``maximum'' element receives the minimum possible
            component values, and the ``minimum'' element receives the maximum
            possible component values. ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "target")
           " is not "
           (code "GL_MINMAX")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glResetMinmax")
           " is executed
            between the execution of "
           (code "glBegin")
           " and the corresponding
            execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glRotate
  "glRotate"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glRotated"))
      (paramdef "GLdouble " (parameter "angle"))
      (paramdef "GLdouble " (parameter "x"))
      (paramdef "GLdouble " (parameter "y"))
      (paramdef "GLdouble " (parameter "z"))))
  '(*fragment*
     (heading
       "multiply the current matrix by a rotation matrix")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "angle")))
                   (para "
Specifies the angle of rotation, in degrees. "))
            (entry (% (heading (var "x")))
                   (itemx (var "y"))
                   (itemx (var "z"))
                   (para "
Specify the "
                         (var "x")
                         ", "
                         (var "y")
                         ", and "
                         (var "z")
                         " coordinates of a vector, respectively. ")))
     (heading "Description")
     (para (code "glRotate")
           " produces a rotation of "
           (var "angle")
           " degrees around
            the vector "
           (math "(" (var "x") "," (var "y") (var "z") ")")
           ".
            The current matrix (see "
           (code "glMatrixMode")
           ") is multiplied by a rotation
            matrix with the product
            replacing the current matrix, as if "
           (code "glMultMatrix")
           " were called
            with the following matrix as its argument: ")
     (para (math "("
                 "("
                 (var "x")
                 "^"
                 "2"
                 "\u2061"
                 "("
                 "1"
                 "-"
                 (var "c")
                 ","
                 ")"
                 "+"
                 (var "c")
                 " "
                 (var "x")
                 "\u2062"
                 (var "y")
                 "\u2061"
                 "("
                 "1"
                 "-"
                 (var "c")
                 ","
                 ")"
                 "-"
                 (var "z")
                 "\u2062"
                 (var "s")
                 " "
                 (var "x")
                 "\u2062"
                 (var "z")
                 "\u2061"
                 "("
                 "1"
                 "-"
                 (var "c")
                 ","
                 ")"
                 "+"
                 (var "y")
                 "\u2062"
                 (var "s")
                 " "
                 "0"
                 ")"
                 ", "
                 "("
                 (var "y")
                 "\u2062"
                 (var "x")
                 "\u2061"
                 "("
                 "1"
                 "-"
                 (var "c")
                 ","
                 ")"
                 "+"
                 (var "z")
                 "\u2062"
                 (var "s")
                 " "
                 (var "y")
                 "^"
                 "2"
                 "\u2061"
                 "("
                 "1"
                 "-"
                 (var "c")
                 ","
                 ")"
                 "+"
                 (var "c")
                 " "
                 (var "y")
                 "\u2062"
                 (var "z")
                 "\u2061"
                 "("
                 "1"
                 "-"
                 (var "c")
                 ","
                 ")"
                 "-"
                 (var "x")
                 "\u2062"
                 (var "s")
                 " "
                 "0"
                 ")"
                 ", "
                 "("
                 (var "x")
                 "\u2062"
                 (var "z")
                 "\u2061"
                 "("
                 "1"
                 "-"
                 (var "c")
                 ","
                 ")"
                 "-"
                 (var "y")
                 "\u2062"
                 (var "s")
                 " "
                 (var "y")
                 "\u2062"
                 (var "z")
                 "\u2061"
                 "("
                 "1"
                 "-"
                 (var "c")
                 ","
                 ")"
                 "+"
                 (var "x")
                 "\u2062"
                 (var "s")
                 " "
                 (var "z")
                 "^"
                 "2"
                 "\u2061"
                 "("
                 "1"
                 "-"
                 (var "c")
                 ","
                 ")"
                 "+"
                 (var "c")
                 " "
                 "0"
                 ")"
                 ", "
                 "("
                 "0"
                 " "
                 "0"
                 " "
                 "0"
                 " "
                 "1"
                 ")"
                 ","
                 ")"))
     (para)
     (para "
Where "
           (math (var "c")
                 "="
                 (var "cos")
                 "\u2061"
                 "("
                 (var "angle")
                 ","
                 ")")
           ", "
           (math (var "s")
                 "="
                 (var "sin")
                 "\u2061"
                 "("
                 (var "angle")
                 ","
                 ")")
           ",
            and "
           (math "∥"
                 "("
                 (var "x")
                 ","
                 (var "y")
                 (var "z")
                 ")"
                 ","
                 "∥"
                 "="
                 "1")
           "
(if not, the GL
            will normalize this vector). ")
     (para)
     (para)
     (para "
If the matrix mode is either "
           (code "GL_MODELVIEW")
           " or "
           (code "GL_PROJECTION")
           ",
            all objects drawn after "
           (code "glRotate")
           " is called are rotated.
            Use "
           (code "glPushMatrix")
           " and "
           (code "glPopMatrix")
           " to save and restore
            the unrotated coordinate system. ")
     (heading "Errors")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glRotate")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glSampleCoverage
  "glSampleCoverage"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glSampleCoverage"))
      (paramdef "GLclampf " (parameter "value"))
      (paramdef "GLboolean " (parameter "invert"))))
  '(*fragment*
     (heading
       "specify multisample coverage parameters")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "value")))
                   (para "
Specify a single floating-point sample coverage value.  The value is
                    clamped to the range "
                         (math "[" "0" "," "1" "]")
                         ".
                    The initial value is 1.0. "))
            (entry (% (heading (var "invert")))
                   (para "
Specify a single boolean value representing if the coverage masks should be
                    inverted. "
                         (code "GL_TRUE")
                         " and "
                         (code "GL_FALSE")
                         " are accepted.  The initial value
                    is "
                         (code "GL_FALSE")
                         ". ")))
     (heading "Description")
     (para "
Multisampling samples a pixel multiple times at various
            implementation-dependent subpixel locations to generate antialiasing
            effects.  Multisampling transparently antialiases points, lines, polygons,
            bitmaps, and images if it is enabled. ")
     (para (var "value")
           " is used in constructing a temporary mask used in determining which
            samples will be used in resolving the final fragment color.  This mask is
            bitwise-anded with the coverage mask generated from the multisampling
            computation.  If the "
           (var "invert")
           " flag is set, the temporary mask is inverted
            (all bits flipped) and then the bitwise-and is computed. ")
     (para "
If an implementation does not have any multisample buffers available, or
            multisampling is disabled, rasterization occurs with only a single sample
            computing a pixel's final RGB color. ")
     (para "
Provided an implementation supports multisample buffers, and multisampling
            is enabled, then a pixel's final color is generated by combining several
            samples per pixel.  Each sample contains color, depth, and stencil
            information, allowing those operations to be performed on each sample. ")
     (heading "Errors")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glSampleCoverage")
           " is executed between the
            execution of "
           (code "glBegin")
           " and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glScale
  "glScale"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glScaled"))
      (paramdef "GLdouble " (parameter "x"))
      (paramdef "GLdouble " (parameter "y"))
      (paramdef "GLdouble " (parameter "z"))))
  '(*fragment*
     (heading
       "multiply the current matrix by a general scaling matrix")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "x")))
                   (itemx (var "y"))
                   (itemx (var "z"))
                   (para "
Specify scale factors along the "
                         (var "x")
                         ", "
                         (var "y")
                         ", and "
                         (var "z")
                         " axes, respectively. ")))
     (heading "Description")
     (para (code "glScale")
           " produces a nonuniform scaling along the "
           (var "x")
           ", "
           (var "y")
           ", and "
           (var "z")
           " axes.
            The three parameters indicate the desired scale factor along
            each of the three axes. ")
     (para "
The current matrix
            (see "
           (code "glMatrixMode")
           ")
            is multiplied by this scale matrix,
            and the product replaces the current matrix
            as if "
           (code "glMultMatrix")
           " were called with the following matrix
            as its argument: ")
     (para (math "("
                 "("
                 (var "x")
                 " "
                 "0"
                 " "
                 "0"
                 " "
                 "0"
                 ")"
                 ", "
                 "("
                 "0"
                 " "
                 (var "y")
                 " "
                 "0"
                 " "
                 "0"
                 ")"
                 ", "
                 "("
                 "0"
                 " "
                 "0"
                 " "
                 (var "z")
                 " "
                 "0"
                 ")"
                 ", "
                 "("
                 "0"
                 " "
                 "0"
                 " "
                 "0"
                 " "
                 "1"
                 ")"
                 ","
                 ")"))
     (para "
If the matrix mode is either "
           (code "GL_MODELVIEW")
           " or "
           (code "GL_PROJECTION")
           ",
            all objects drawn after "
           (code "glScale")
           " is called are scaled. ")
     (para "
Use "
           (code "glPushMatrix")
           " and "
           (code "glPopMatrix")
           " to save and restore
            the unscaled coordinate
            system. ")
     (heading "Errors")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glScale")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glScissor
  "glScissor"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glScissor"))
      (paramdef "GLint " (parameter "x"))
      (paramdef "GLint " (parameter "y"))
      (paramdef "GLsizei " (parameter "width"))
      (paramdef "GLsizei " (parameter "height"))))
  '(*fragment*
     (heading "define the scissor box")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "x")))
                   (itemx (var "y"))
                   (para "
Specify the lower left corner of the scissor box.
                    Initially (0, 0). "))
            (entry (% (heading (var "width")))
                   (itemx (var "height"))
                   (para "
Specify the width and height of the scissor box.
                    When a GL context is first attached to a window, "
                         (var "width")
                         " and "
                         (var "height")
                         " are set to the dimensions of that
                    window. ")))
     (heading "Description")
     (para (code "glScissor")
           " defines a rectangle, called the scissor box,
            in window coordinates.
            The first two arguments, "
           (var "x")
           " and "
           (var "y")
           ",
            specify the lower left corner of the box. "
           (var "width")
           " and "
           (var "height")
           " specify the width and height of the box. ")
     (para "
To enable and disable the scissor test, call "
           (code "glEnable")
           " and "
           (code "glDisable")
           " with argument "
           (code "GL_SCISSOR_TEST")
           ". The test is initially disabled.
            While the test is enabled, only pixels that lie within the scissor box
            can be modified by drawing commands.
            Window coordinates have integer values at the shared corners of
            frame buffer pixels. "
           (code "glScissor(0,0,1,1)")
           " allows modification of only the lower left
            pixel in the window, and "
           (code "glScissor(0,0,0,0)")
           " doesn't allow
            modification of any pixels in the window. ")
     (para "
When the scissor test is disabled,
            it is as though the scissor box includes the entire window. ")
     (heading "Errors")
     (para (code "GL_INVALID_VALUE")
           " is generated if either "
           (var "width")
           " or "
           (var "height")
           " is negative. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glScissor")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glSecondaryColorPointer
  "glSecondaryColorPointer"
  (funcsynopsis
    (funcprototype
      (funcdef
        "void "
        (function "glSecondaryColorPointer"))
      (paramdef "GLint " (parameter "size"))
      (paramdef "GLenum " (parameter "type"))
      (paramdef "GLsizei " (parameter "stride"))
      (paramdef
        "const GLvoid * "
        (parameter "pointer"))))
  '(*fragment*
     (heading "define an array of secondary colors")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "size")))
                   (para "
Specifies the number of components per color. Must be 3. "))
            (entry (% (heading (var "type")))
                   (para "
Specifies the data type of each color component in the array.
                    Symbolic constants "
                         (code "GL_BYTE")
                         ", "
                         (code "GL_UNSIGNED_BYTE")
                         ", "
                         (code "GL_SHORT")
                         ", "
                         (code "GL_UNSIGNED_SHORT")
                         ", "
                         (code "GL_INT")
                         ", "
                         (code "GL_UNSIGNED_INT")
                         ", "
                         (code "GL_FLOAT")
                         ",
                    or "
                         (code "GL_DOUBLE")
                         "
are accepted.
                    The initial value is "
                         (code "GL_FLOAT")
                         ". "))
            (entry (% (heading (var "stride")))
                   (para "
Specifies the byte offset between consecutive colors.
                    If "
                         (var "stride")
                         " is 0, the colors are understood to be
                    tightly packed in the array. The initial value is 0. "))
            (entry (% (heading (var "pointer")))
                   (para "
Specifies a pointer to the first component of the first color element
                    in the array. The initial value is 0. ")))
     (heading "Description")
     (para (code "glSecondaryColorPointer")
           " specifies the location and data format of an array of color components
            to use when rendering. "
           (var "size")
           " specifies the number of components per color, and must be 3. "
           (var "type")
           " specifies the data type of each color component, and "
           (var "stride")
           "
specifies the byte stride from one color to the next, allowing vertices and
            attributes to be packed into a single array or stored in separate arrays. ")
     (para "
If a non-zero named buffer object is bound to the "
           (code "GL_ARRAY_BUFFER")
           " target 
            (see "
           (code "glBindBuffer")
           ") while a secondary color array is
            specified, "
           (var "pointer")
           " is treated as a byte offset into the buffer object's data store.
            Also, the buffer object binding ("
           (code "GL_ARRAY_BUFFER_BINDING")
           ") is saved as secondary color vertex array
            client-side state ("
           (code "GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING")
           "). ")
     (para "
When a secondary color array is specified, "
           (var "size")
           ", "
           (var "type")
           ", "
           (var "stride")
           ", and "
           (var "pointer")
           " are saved as client-side
            state, in addition to the current vertex array buffer object binding. ")
     (para "
To enable and disable the secondary color array, call "
           (code "glEnableClientState")
           " and "
           (code "glDisableClientState")
           " with the argument "
           (code "GL_SECONDARY_COLOR_ARRAY")
           ". If enabled, the secondary color array is used when "
           (code "glArrayElement")
           ", "
           (code "glDrawArrays")
           ", "
           (code "glMultiDrawArrays")
           ", "
           (code "glDrawElements")
           ", "
           (code "glMultiDrawElements")
           ", or "
           (code "glDrawRangeElements")
           "
is called. ")
     (heading "Errors")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "size")
           " is not 3. ")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "type")
           " is not an accepted value. ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "stride")
           " is negative. ")))

(define-gl-procedure
  glSecondaryColor
  "glSecondaryColor"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glSecondaryColor3b"))
      (paramdef "GLbyte " (parameter "red"))
      (paramdef "GLbyte " (parameter "green"))
      (paramdef "GLbyte " (parameter "blue"))))
  '(*fragment*
     (heading "set the current secondary color")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "red")))
                   (itemx (var "green"))
                   (itemx (var "blue"))
                   (para "
Specify new red, green, and blue values for the current secondary color. ")))
     (heading "Description")
     (para "
The GL stores both a primary four-valued RGBA color and a
            secondary four-valued RGBA color (where alpha is always set to 0.0) that is
            associated with every vertex. ")
     (para "
The secondary color is interpolated and applied to each fragment during
            rasterization when "
           (code "GL_COLOR_SUM")
           " is enabled.  When lighting is enabled,
            and "
           (code "GL_SEPARATE_SPECULAR_COLOR")
           " is specified, the value of the
            secondary color is assigned the value computed from the specular term of
            the lighting computation. Both the primary and secondary current colors are
            applied to each fragment, regardless of the state of "
           (code "GL_COLOR_SUM")
           ",
            under such conditions.  When "
           (code "GL_SEPARATE_SPECULAR_COLOR")
           " is specified,
            the value returned from querying the current secondary color is undefined. ")
     (para (code "glSecondaryColor3b")
           ", "
           (code "glSecondaryColor3s")
           ", and "
           (code "glSecondaryColor3i")
           " take three signed byte, short, or long integers as
            arguments.  When "
           (strong "v")
           " is appended to the name, the color commands can
            take a pointer to an array of such values. ")
     (para "
Color values are stored in floating-point format, with
            unspecified mantissa and exponent sizes.  Unsigned integer color
            components, when specified, are linearly mapped to floating-point values
            such that the largest representable value maps to 1.0 (full intensity), and
            0 maps to 0.0 (zero intensity).  Signed integer color components, when
            specified, are linearly mapped to floating-point values such that the most
            positive representable value maps to 1.0, and the most negative
            representable value maps to "
           (math "-1.0")
           ".
            (Note that this mapping does not convert
            0 precisely to 0.0).  Floating-point values are mapped directly. ")
     (para "
Neither floating-point nor signed integer values are clamped to the range "
           (math "[" "0" "," "1" "]")
           "
before the current color is updated.  However, color components are
            clamped to this range before they are interpolated or written into a color
            buffer. ")))

(define-gl-procedure
  glSelectBuffer
  "glSelectBuffer"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glSelectBuffer"))
      (paramdef "GLsizei " (parameter "size"))
      (paramdef "GLuint * " (parameter "buffer"))))
  '(*fragment*
     (heading
       "establish a buffer for selection mode values")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "size")))
                   (para "
Specifies the size of "
                         (var "buffer")
                         ". "))
            (entry (% (heading (var "buffer")))
                   (para "
Returns the selection data. ")))
     (heading "Description")
     (para (code "glSelectBuffer")
           " has two arguments: "
           (var "buffer")
           " is a pointer to an array of unsigned integers,
            and "
           (var "size")
           " indicates the size of the array. "
           (var "buffer")
           " returns values from the name stack
            (see "
           (code "glInitNames")
           ", "
           (code "glLoadName")
           ", "
           (code "glPushName")
           ")
            when the rendering mode is "
           (code "GL_SELECT")
           " (see "
           (code "glRenderMode")
           "). "
           (code "glSelectBuffer")
           " must be issued before selection mode is enabled,
            and it must not be issued while the rendering mode is "
           (code "GL_SELECT")
           ". ")
     (para "
A programmer can use selection to determine which primitives
            are drawn into some region of a window.
            The region is defined by the current modelview and perspective matrices. ")
     (para "
In selection mode, no pixel fragments are produced from rasterization.
            Instead,
            if a primitive or a raster position intersects the clipping
            volume defined by the viewing frustum
            and the user-defined clipping planes,
            this primitive causes a selection hit.
            (With polygons, no hit occurs if the polygon is culled.)
            When a change is made to the name stack,
            or when "
           (code "glRenderMode")
           " is called,
            a hit record is copied to "
           (var "buffer")
           " if any hits have occurred since the
            last such event
            (name stack change or "
           (code "glRenderMode")
           " call).
            The hit record consists of the number of names in the name stack at the
            time of the event, followed by the minimum and maximum depth values
            of all vertices that hit since the previous event,
            followed by the name stack contents,
            bottom name first. ")
     (para "
Depth values (which are in the range [0,1]) are multiplied by "
           (math "2" "^" "32" "-" "1")
           ",
            before being placed in the hit record. ")
     (para "
An internal index into "
           (var "buffer")
           " is reset to 0 whenever selection mode
            is entered.
            Each time a hit record is copied into "
           (var "buffer")
           ",
            the index is incremented to point to the cell just past the end
            of the block of names\\(emthat is, to the next available cell
            If the hit record is larger than the number of remaining locations in "
           (var "buffer")
           ",
            as much data as can fit is copied,
            and the overflow flag is set.
            If the name stack is empty when a hit record is copied,
            that record consists of 0 followed by the minimum and maximum depth values. ")
     (para "
To exit selection mode, call "
           (code "glRenderMode")
           " with an argument
            other than "
           (code "GL_SELECT")
           ".
            Whenever "
           (code "glRenderMode")
           " is called while the render mode is "
           (code "GL_SELECT")
           ",
            it returns the number of hit records copied to "
           (var "buffer")
           ",
            resets the overflow flag and the selection buffer pointer,
            and initializes the name stack to be empty.
            If the overflow bit was set when "
           (code "glRenderMode")
           " was called,
            a negative hit record count is returned. ")
     (heading "Errors")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "size")
           " is negative. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glSelectBuffer")
           " is called while the
            render mode is "
           (code "GL_SELECT")
           ",
            or if "
           (code "glRenderMode")
           " is called with argument "
           (code "GL_SELECT")
           " before "
           (code "glSelectBuffer")
           " is called at least once. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glSelectBuffer")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glSeparableFilter2D
  "glSeparableFilter2D"
  (funcsynopsis
    (funcprototype
      (funcdef
        "void "
        (function "glSeparableFilter2D"))
      (paramdef "GLenum " (parameter "target"))
      (paramdef "GLenum " (parameter "internalformat"))
      (paramdef "GLsizei " (parameter "width"))
      (paramdef "GLsizei " (parameter "height"))
      (paramdef "GLenum " (parameter "format"))
      (paramdef "GLenum " (parameter "type"))
      (paramdef "const GLvoid * " (parameter "row"))
      (paramdef "const GLvoid * " (parameter "column"))))
  '(*fragment*
     (heading
       "define a separable two-dimensional convolution filter")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "target")))
                   (para "
Must be " (code "GL_SEPARABLE_2D") ". "))
            (entry (% (heading (var "internalformat")))
                   (para "
The internal format of the convolution filter kernel.
                    The allowable values are "
                         (code "GL_ALPHA")
                         ", "
                         (code "GL_ALPHA4")
                         ", "
                         (code "GL_ALPHA8")
                         ", "
                         (code "GL_ALPHA12")
                         ", "
                         (code "GL_ALPHA16")
                         ", "
                         (code "GL_LUMINANCE")
                         ", "
                         (code "GL_LUMINANCE4")
                         ", "
                         (code "GL_LUMINANCE8")
                         ", "
                         (code "GL_LUMINANCE12")
                         ", "
                         (code "GL_LUMINANCE16")
                         ", "
                         (code "GL_LUMINANCE_ALPHA")
                         ", "
                         (code "GL_LUMINANCE4_ALPHA4")
                         ", "
                         (code "GL_LUMINANCE6_ALPHA2")
                         ", "
                         (code "GL_LUMINANCE8_ALPHA8")
                         ", "
                         (code "GL_LUMINANCE12_ALPHA4")
                         ", "
                         (code "GL_LUMINANCE12_ALPHA12")
                         ", "
                         (code "GL_LUMINANCE16_ALPHA16")
                         ", "
                         (code "GL_INTENSITY")
                         ", "
                         (code "GL_INTENSITY4")
                         ", "
                         (code "GL_INTENSITY8")
                         ", "
                         (code "GL_INTENSITY12")
                         ", "
                         (code "GL_INTENSITY16")
                         ", "
                         (code "GL_R3_G3_B2")
                         ", "
                         (code "GL_RGB")
                         ", "
                         (code "GL_RGB4")
                         ", "
                         (code "GL_RGB5")
                         ", "
                         (code "GL_RGB8")
                         ", "
                         (code "GL_RGB10")
                         ", "
                         (code "GL_RGB12")
                         ", "
                         (code "GL_RGB16")
                         ", "
                         (code "GL_RGBA")
                         ", "
                         (code "GL_RGBA2")
                         ", "
                         (code "GL_RGBA4")
                         ", "
                         (code "GL_RGB5_A1")
                         ", "
                         (code "GL_RGBA8")
                         ", "
                         (code "GL_RGB10_A2")
                         ", "
                         (code "GL_RGBA12")
                         ", or "
                         (code "GL_RGBA16")
                         ". "))
            (entry (% (heading (var "width")))
                   (para "
The number of elements in the pixel array referenced by "
                         (var "row")
                         ".
                    (This is the width of the separable filter kernel.) "))
            (entry (% (heading (var "height")))
                   (para "
The number of elements in the pixel array referenced by "
                         (var "column")
                         ".
                    (This is the height of the separable filter kernel.) "))
            (entry (% (heading (var "format")))
                   (para "
The format of the pixel data in "
                         (var "row")
                         " and "
                         (var "column")
                         ".
                    The allowable values are "
                         (code "GL_RED")
                         ", "
                         (code "GL_GREEN")
                         ", "
                         (code "GL_BLUE")
                         ", "
                         (code "GL_ALPHA")
                         ", "
                         (code "GL_RGB")
                         ", "
                         (code "GL_BGR")
                         ", "
                         (code "GL_RGBA")
                         ", "
                         (code "GL_BGRA")
                         ", "
                         (code "GL_INTENSITY")
                         ", "
                         (code "GL_LUMINANCE")
                         ", and "
                         (code "GL_LUMINANCE_ALPHA")
                         ". "))
            (entry (% (heading (var "type")))
                   (para "
The type of the pixel data in "
                         (var "row")
                         " and "
                         (var "column")
                         ".
                    Symbolic constants "
                         (code "GL_UNSIGNED_BYTE")
                         ", "
                         (code "GL_BYTE")
                         ", "
                         (code "GL_BITMAP")
                         ", "
                         (code "GL_UNSIGNED_SHORT")
                         ", "
                         (code "GL_SHORT")
                         ", "
                         (code "GL_UNSIGNED_INT")
                         ", "
                         (code "GL_INT")
                         ", "
                         (code "GL_FLOAT")
                         ", "
                         (code "GL_UNSIGNED_BYTE_3_3_2")
                         ", "
                         (code "GL_UNSIGNED_BYTE_2_3_3_REV")
                         ", "
                         (code "GL_UNSIGNED_SHORT_5_6_5")
                         ", "
                         (code "GL_UNSIGNED_SHORT_5_6_5_REV")
                         ", "
                         (code "GL_UNSIGNED_SHORT_4_4_4_4")
                         ", "
                         (code "GL_UNSIGNED_SHORT_4_4_4_4_REV")
                         ", "
                         (code "GL_UNSIGNED_SHORT_5_5_5_1")
                         ", "
                         (code "GL_UNSIGNED_SHORT_1_5_5_5_REV")
                         ", "
                         (code "GL_UNSIGNED_INT_8_8_8_8")
                         ", "
                         (code "GL_UNSIGNED_INT_8_8_8_8_REV")
                         ", "
                         (code "GL_UNSIGNED_INT_10_10_10_2")
                         ", and "
                         (code "GL_UNSIGNED_INT_2_10_10_10_REV")
                         "
are accepted. "))
            (entry (% (heading (var "row")))
                   (para "
Pointer to a one-dimensional array of pixel data that is processed to
                    build the row filter kernel. "))
            (entry (% (heading (var "column")))
                   (para "
Pointer to a one-dimensional array of pixel data that is processed to
                    build the column filter kernel. ")))
     (heading "Description")
     (para (code "glSeparableFilter2D")
           " builds a two-dimensional separable convolution filter kernel from
            two arrays of pixels. ")
     (para "
The pixel arrays specified by ("
           (var "width")
           ", "
           (var "format")
           ", "
           (var "type")
           ", "
           (var "row")
           ")
            and ("
           (var "height")
           ", "
           (var "format")
           ", "
           (var "type")
           ", "
           (var "column")
           ") are processed just as if
            they had been passed to "
           (code "glDrawPixels")
           ",
            but processing stops after the final expansion to RGBA is completed. ")
     (para "
If a non-zero named buffer object is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target 
            (see "
           (code "glBindBuffer")
           ") while a convolution filter is
            specified, "
           (var "row")
           " and "
           (var "column")
           " are treated as byte offsets into the buffer object's data store. ")
     (para "
Next, the R, G, B, and A components of all pixels in both arrays are scaled
            by the four separable 2D "
           (code "GL_CONVOLUTION_FILTER_SCALE")
           " parameters and
            biased by the four separable 2D "
           (code "GL_CONVOLUTION_FILTER_BIAS")
           " parameters.
            (The scale and bias parameters are set by "
           (code "glConvolutionParameter")
           "
using the "
           (code "GL_SEPARABLE_2D")
           " target and the names "
           (code "GL_CONVOLUTION_FILTER_SCALE")
           " and "
           (code "GL_CONVOLUTION_FILTER_BIAS")
           ".
            The parameters themselves are vectors of four values that are applied to red,
            green, blue, and alpha, in that order.)
            The R, G, B, and A values are not clamped to [0,1] at any time during this
            process. ")
     (para "
Each pixel is then converted to the internal format specified by "
           (var "internalformat")
           ".
            This conversion simply maps the component values of the pixel (R, G, B,
            and A) to the values included in the internal format (red, green, blue,
            alpha, luminance, and intensity).  The mapping is as follows: ")
     (table (% (formatter (asis)))
            (entry (% (heading (strong "Internal Format")))
                   (para (strong "Red")
                         ", "
                         (strong "Green")
                         ", "
                         (strong "Blue")
                         ", "
                         (strong "Alpha")
                         ", "
                         (strong "Luminance")
                         ", "
                         (strong "Intensity")))
            (entry (% (heading (code "GL_LUMINANCE")))
                   (para ", " ", " ", " ", " "
R " ", "))
            (entry (% (heading (code "GL_LUMINANCE_ALPHA")))
                   (para ", " ", " ", " "
A " ", " "
R " ", "))
            (entry (% (heading (code "GL_INTENSITY")))
                   (para ", " ", " ", " ", " ", " "
R "))
            (entry (% (heading (code "GL_RGB")))
                   (para "
R " ", " "
G " ", " "
B " ", " ", " ", "))
            (entry (% (heading (code "GL_RGBA")))
                   (para "
R "
                         ", "
                         "
G "
                         ", "
                         "
B "
                         ", "
                         "
A "
                         ", "
                         ", ")))
     (para "
The red, green, blue, alpha, luminance, and/or intensity components of
            the resulting pixels are stored in floating-point rather than integer
            format.
            They form two one-dimensional filter kernel images.
            The row image is indexed by coordinate "
           (var "i")
           " starting at zero and
            increasing from left to right.
            Each location in the row image is derived from element "
           (var "i")
           " of "
           (var "row")
           ".
            The column image is indexed by coordinate "
           (var "j")
           " starting at zero
            and increasing from bottom to top.
            Each location in the column image is derived from element "
           (var "j")
           " of "
           (var "column")
           ". ")
     (para "
Note that after a convolution is performed, the resulting color
            components are also scaled by their corresponding "
           (code "GL_POST_CONVOLUTION_c_SCALE")
           " parameters and biased by their
            corresponding "
           (code "GL_POST_CONVOLUTION_c_BIAS")
           " parameters (where "
           (var "c")
           " takes on the values "
           (strong "RED")
           ", "
           (strong "GREEN")
           ", "
           (strong "BLUE")
           ", and "
           (strong "ALPHA")
           ").
            These parameters are set by "
           (code "glPixelTransfer")
           ". ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "target")
           " is not "
           (code "GL_SEPARABLE_2D")
           ". ")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "internalformat")
           " is not one of the
            allowable values. ")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "format")
           " is not one of the allowable
            values. ")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "type")
           " is not one of the allowable
            values. ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "width")
           " is less than zero or greater
            than the maximum supported value.
            This value may be queried with "
           (code "glGetConvolutionParameter")
           "
using target "
           (code "GL_SEPARABLE_2D")
           " and name "
           (code "GL_MAX_CONVOLUTION_WIDTH")
           ". ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "height")
           " is less than zero or greater
            than the maximum supported value.
            This value may be queried with "
           (code "glGetConvolutionParameter")
           "
using target "
           (code "GL_SEPARABLE_2D")
           " and name "
           (code "GL_MAX_CONVOLUTION_HEIGHT")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (var "height")
           " is one of "
           (code "GL_UNSIGNED_BYTE_3_3_2")
           ", "
           (code "GL_UNSIGNED_BYTE_2_3_3_REV")
           ", "
           (code "GL_UNSIGNED_SHORT_5_6_5")
           ", or "
           (code "GL_UNSIGNED_SHORT_5_6_5_REV")
           "
and "
           (var "format")
           " is not "
           (code "GL_RGB")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (var "height")
           " is one of "
           (code "GL_UNSIGNED_SHORT_4_4_4_4")
           ", "
           (code "GL_UNSIGNED_SHORT_4_4_4_4_REV")
           ", "
           (code "GL_UNSIGNED_SHORT_5_5_5_1")
           ", "
           (code "GL_UNSIGNED_SHORT_1_5_5_5_REV")
           ", "
           (code "GL_UNSIGNED_INT_8_8_8_8")
           ", "
           (code "GL_UNSIGNED_INT_8_8_8_8_REV")
           ", "
           (code "GL_UNSIGNED_INT_10_10_10_2")
           ", or "
           (code "GL_UNSIGNED_INT_2_10_10_10_REV")
           "
and "
           (var "format")
           " is neither "
           (code "GL_RGBA")
           " nor "
           (code "GL_BGRA")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target and the buffer object's data store is currently mapped. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target and the data would be unpacked from the buffer 
            object such that the memory reads required would exceed the data store size. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target and "
           (var "row")
           " or "
           (var "column")
           " is not evenly divisible 
            into the number of bytes needed to store in memory a datum indicated by "
           (var "type")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glSeparableFilter2D")
           " is executed
            between the execution of "
           (code "glBegin")
           " and the corresponding
            execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glShadeModel
  "glShadeModel"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glShadeModel"))
      (paramdef "GLenum " (parameter "mode"))))
  '(*fragment*
     (heading "select flat or smooth shading")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "mode")))
                   (para "
Specifies a symbolic value representing a shading technique.
                    Accepted values are "
                         (code "GL_FLAT")
                         " and "
                         (code "GL_SMOOTH")
                         ".
                    The initial value is "
                         (code "GL_SMOOTH")
                         ". ")))
     (heading "Description")
     (para "
GL primitives can have either flat or smooth shading.
            Smooth shading,
            the default,
            causes the computed colors of vertices to be interpolated as the
            primitive is rasterized,
            typically assigning different colors to each resulting pixel fragment.
            Flat shading selects the computed color of just one vertex
            and assigns it to all the pixel fragments
            generated by rasterizing a single primitive.
            In either case, the computed color of a vertex is the result of
            lighting if lighting is enabled,
            or it is the current color at the time the vertex was specified if
            lighting is disabled. ")
     (para "
Flat and smooth shading are indistinguishable for points.
            Starting when "
           (code "glBegin")
           " is issued and counting vertices and
            primitives from 1, the GL gives each flat-shaded line segment "
           (math (var "i"))
           "
the
            computed color of vertex "
           (math (var "i") "+" "1")
           ",
            its second vertex.
            Counting similarly from 1,
            the GL gives each flat-shaded polygon the computed color of the vertex listed
            in the following table.
            This is the last vertex to specify the polygon in all cases except single
            polygons,
            where the first vertex specifies the flat-shaded color. ")
     (para)
     (table (% (formatter (asis)))
            (entry (% (heading
                        (strong
                          "
Primitive Type of Polygon "
                          (math (var "i")))))
                   (para (strong "Vertex")))
            (entry (% (heading
                        "
Single polygon 
                        ("
                        (math (var "i") "==" "1")
                        ") "))
                   (para "
1 "))
            (entry (% (heading "
Triangle strip "))
                   (para (math (var "i") "+" "2")))
            (entry (% (heading "
Triangle fan "))
                   (para (math (var "i") "+" "2")))
            (entry (% (heading "
Independent triangle "))
                   (para (math "3" "\u2062" (var "i"))))
            (entry (% (heading "
Quad strip "))
                   (para (math "2" "\u2062" (var "i") "+" "2")))
            (entry (% (heading "
Independent quad "))
                   (para (math "4" "\u2062" (var "i")))))
     (para "
Flat and smooth shading are specified by "
           (code "glShadeModel")
           " with "
           (var "mode")
           " set to "
           (code "GL_FLAT")
           " and "
           (code "GL_SMOOTH")
           ", respectively. ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "mode")
           " is any value other than "
           (code "GL_FLAT")
           " or "
           (code "GL_SMOOTH")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glShadeModel")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glShaderSource
  "glShaderSource"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glShaderSource"))
      (paramdef "GLuint " (parameter "shader"))
      (paramdef "GLsizei " (parameter "count"))
      (paramdef "const GLchar **" (parameter "string"))
      (paramdef "const GLint *" (parameter "length"))))
  '(*fragment*
     (heading
       "Replaces the source code in a shader object")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "shader")))
                   (para "Specifies the handle of the shader object
\t\t    whose source code is to be replaced."))
            (entry (% (heading (var "count")))
                   (para "Specifies the number of elements in the "
                         (var "string")
                         " and "
                         (var "length")
                         "
arrays."))
            (entry (% (heading (var "string")))
                   (para "Specifies an array of pointers to strings
\t\t    containing the source code to be loaded into the
\t\t    shader."))
            (entry (% (heading (var "length")))
                   (para "Specifies an array of string lengths.")))
     (heading "Description")
     (para (code "glShaderSource")
           " sets the source code
\tin "
           (var "shader")
           " to the source code in the array
\tof strings specified by "
           (var "string")
           ". Any
\tsource code previously stored in the shader object is completely
\treplaced. The number of strings in the array is specified by\t"
           (var "count")
           ". If "
           (var "length")
           "
is "
           (code "NULL")
           ", each string is assumed to be null
\tterminated. If "
           (var "length")
           " is a value other
\tthan "
           (code "NULL")
           ", it points to an array containing
\ta string length for each of the corresponding elements of\t"
           (var "string")
           ". Each element in the\t"
           (var "length")
           " array may contain the length of
\tthe corresponding string (the null character is not counted as
\tpart of the string length) or a value less than 0 to indicate
\tthat the string is null terminated. The source code strings are
\tnot scanned or parsed at this time; they are simply copied into
\tthe specified shader object.")
     (heading "Errors")
     (para (code "GL_INVALID_VALUE")
           " is generated if\t"
           (var "shader")
           " is not a value generated by
\tOpenGL.")
     (para (code "GL_INVALID_OPERATION")
           " is generated if\t"
           (var "shader")
           " is not a shader object.")
     (para (code "GL_INVALID_VALUE")
           " is generated if\t"
           (var "count")
           " is less than 0.")
     (para (code "GL_INVALID_OPERATION")
           " is generated if\t"
           (code "glShaderSource")
           " is executed between the
\texecution of\t"
           (code "glBegin")
           "
and the corresponding execution of\t"
           (code "glEnd")
           ".")))

(define-gl-procedure
  glStencilFuncSeparate
  "glStencilFuncSeparate"
  (funcsynopsis
    (funcprototype
      (funcdef
        "void "
        (function "glStencilFuncSeparate"))
      (paramdef "GLenum " (parameter "face"))
      (paramdef "GLenum " (parameter "func"))
      (paramdef "GLint " (parameter "ref"))
      (paramdef "GLuint " (parameter "mask"))))
  '(*fragment*
     (heading
       "set front and/or back function and reference value for stencil testing")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "face")))
                   (para "
Specifies whether front and/or back stencil state is updated.
                    Three symbolic constants are valid: "
                         (code "GL_FRONT")
                         ", "
                         (code "GL_BACK")
                         ", and "
                         (code "GL_FRONT_AND_BACK")
                         ". "))
            (entry (% (heading (var "func")))
                   (para "
Specifies the test function.
                    Eight symbolic constants are valid: "
                         (code "GL_NEVER")
                         ", "
                         (code "GL_LESS")
                         ", "
                         (code "GL_LEQUAL")
                         ", "
                         (code "GL_GREATER")
                         ", "
                         (code "GL_GEQUAL")
                         ", "
                         (code "GL_EQUAL")
                         ", "
                         (code "GL_NOTEQUAL")
                         ", and "
                         (code "GL_ALWAYS")
                         ". The initial value is "
                         (code "GL_ALWAYS")
                         ". "))
            (entry (% (heading (var "ref")))
                   (para "
Specifies the reference value for the stencil test. "
                         (var "ref")
                         " is clamped to the range "
                         (math "[" "0" "," "2" "^" (var "n") "-" "1" "]")
                         ",
                    where "
                         (math (var "n"))
                         "
is the number of bitplanes in the stencil buffer. The
                    initial value is 0. "))
            (entry (% (heading (var "mask")))
                   (para "
Specifies a mask that is ANDed with both the reference value
                    and the stored stencil value when the test is done. The initial value
                    is all 1's. ")))
     (heading "Description")
     (para "
Stenciling,
            like depth-buffering,
            enables and disables drawing on a per-pixel basis.
            You draw into the stencil planes using GL drawing primitives,
            then render geometry and images,
            using the stencil planes to mask out portions of the screen.
            Stenciling is typically used in multipass rendering algorithms
            to achieve special effects,
            such as decals,
            outlining,
            and constructive solid geometry rendering. ")
     (para "
The stencil test conditionally eliminates a pixel based on the outcome
            of a comparison between the reference value
            and the value in the stencil buffer.
            To enable and disable the test, call "
           (code "glEnable")
           " and "
           (code "glDisable")
           "
with argument "
           (code "GL_STENCIL_TEST")
           ".
            To specify actions based on the outcome of the stencil test, call "
           (code "glStencilOp")
           " or "
           (code "glStencilOpSeparate")
           ". ")
     (para "
There can be two separate sets of "
           (var "func")
           ", "
           (var "ref")
           ", and "
           (var "mask")
           " parameters; one affects back-facing polygons, and the other
            affects front-facing polygons as well as other non-polygon primitives. "
           (code "glStencilFunc")
           " sets both front
            and back stencil state to the same values, as if "
           (code "glStencilFuncSeparate")
           " were called
            with "
           (var "face")
           " set to "
           (code "GL_FRONT_AND_BACK")
           ". ")
     (para (var "func")
           " is a symbolic constant that determines the stencil comparison function.
            It accepts one of eight values,
            shown in the following list. "
           (var "ref")
           " is an integer reference value that is used in the stencil comparison.
            It is clamped to the range "
           (math "[" "0" "," "2" "^" (var "n") "-" "1" "]")
           ",
            where "
           (math (var "n"))
           "
is the number of bitplanes in the stencil buffer. "
           (var "mask")
           " is bitwise ANDed with both the reference value
            and the stored stencil value,
            with the ANDed values participating in the comparison. ")
     (para "
If "
           (var "stencil")
           " represents the value stored in the corresponding
            stencil buffer location,
            the following list shows the effect of each comparison function
            that can be specified by "
           (var "func")
           ".
            Only if the comparison succeeds is the pixel passed through
            to the next stage in the rasterization process
            (see "
           (code "glStencilOp")
           ").
            All tests treat "
           (var "stencil")
           " values as unsigned integers in the range "
           (math "[" "0" "," "2" "^" (var "n") "-" "1" "]")
           ",
            where "
           (math (var "n"))
           "
is the number of bitplanes in the stencil buffer. ")
     (para "
The following values are accepted by "
           (var "func")
           ": ")
     (table (% (formatter (asis)))
            (entry (% (heading (code "GL_NEVER")))
                   (para "
Always fails. "))
            (entry (% (heading (code "GL_LESS")))
                   (para "
Passes if ( "
                         (var "ref")
                         " & "
                         (var "mask")
                         " ) < ( "
                         (var "stencil")
                         " & "
                         (var "mask")
                         " ). "))
            (entry (% (heading (code "GL_LEQUAL")))
                   (para "
Passes if ( "
                         (var "ref")
                         " & "
                         (var "mask")
                         " ) <= ( "
                         (var "stencil")
                         " & "
                         (var "mask")
                         " ). "))
            (entry (% (heading (code "GL_GREATER")))
                   (para "
Passes if ( "
                         (var "ref")
                         " & "
                         (var "mask")
                         " ) > ( "
                         (var "stencil")
                         " & "
                         (var "mask")
                         " ). "))
            (entry (% (heading (code "GL_GEQUAL")))
                   (para "
Passes if ( "
                         (var "ref")
                         " & "
                         (var "mask")
                         " ) >= ( "
                         (var "stencil")
                         " & "
                         (var "mask")
                         " ). "))
            (entry (% (heading (code "GL_EQUAL")))
                   (para "
Passes if ( "
                         (var "ref")
                         " & "
                         (var "mask")
                         " ) = ( "
                         (var "stencil")
                         " & "
                         (var "mask")
                         " ). "))
            (entry (% (heading (code "GL_NOTEQUAL")))
                   (para "
Passes if ( "
                         (var "ref")
                         " & "
                         (var "mask")
                         " ) != ( "
                         (var "stencil")
                         " & "
                         (var "mask")
                         " ). "))
            (entry (% (heading (code "GL_ALWAYS")))
                   (para "
Always passes. ")))
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "func")
           " is not one of the eight
            accepted values. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glStencilFuncSeparate")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glStencilFunc
  "glStencilFunc"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glStencilFunc"))
      (paramdef "GLenum " (parameter "func"))
      (paramdef "GLint " (parameter "ref"))
      (paramdef "GLuint " (parameter "mask"))))
  '(*fragment*
     (heading
       "set front and back function and reference value for stencil testing")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "func")))
                   (para "
Specifies the test function.
                    Eight symbolic constants are valid: "
                         (code "GL_NEVER")
                         ", "
                         (code "GL_LESS")
                         ", "
                         (code "GL_LEQUAL")
                         ", "
                         (code "GL_GREATER")
                         ", "
                         (code "GL_GEQUAL")
                         ", "
                         (code "GL_EQUAL")
                         ", "
                         (code "GL_NOTEQUAL")
                         ", and "
                         (code "GL_ALWAYS")
                         ". The initial value is "
                         (code "GL_ALWAYS")
                         ". "))
            (entry (% (heading (var "ref")))
                   (para "
Specifies the reference value for the stencil test. "
                         (var "ref")
                         " is clamped to the range "
                         (math "[" "0" "," "2" "^" (var "n") "-" "1" "]")
                         ",
                    where "
                         (math (var "n"))
                         "
is the number of bitplanes in the stencil buffer. The
                    initial value is 0. "))
            (entry (% (heading (var "mask")))
                   (para "
Specifies a mask that is ANDed with both the reference value
                    and the stored stencil value when the test is done. The initial value
                    is all 1's. ")))
     (heading "Description")
     (para "
Stenciling,
            like depth-buffering,
            enables and disables drawing on a per-pixel basis.
            Stencil planes are first drawn into using GL drawing primitives, then
            geometry and images are rendered using the stencil planes to mask out
            portions of the screen.
            Stenciling is typically used in multipass rendering algorithms
            to achieve special effects,
            such as decals,
            outlining,
            and constructive solid geometry rendering. ")
     (para "
The stencil test conditionally eliminates a pixel based on the outcome
            of a comparison between the reference value
            and the value in the stencil buffer.
            To enable and disable the test, call "
           (code "glEnable")
           " and "
           (code "glDisable")
           "
with argument "
           (code "GL_STENCIL_TEST")
           ".
            To specify actions based on the outcome of the stencil test, call "
           (code "glStencilOp")
           " or "
           (code "glStencilOpSeparate")
           ". ")
     (para "
There can be two separate sets of "
           (var "func")
           ", "
           (var "ref")
           ", and "
           (var "mask")
           " parameters; one affects back-facing polygons, and the other
            affects front-facing polygons as well as other non-polygon primitives. "
           (code "glStencilFunc")
           " sets both front
            and back stencil state to the same values. Use "
           (code "glStencilFuncSeparate")
           "
to set front and back stencil state to different values. ")
     (para (var "func")
           " is a symbolic constant that determines the stencil comparison function.
            It accepts one of eight values,
            shown in the following list. "
           (var "ref")
           " is an integer reference value that is used in the stencil comparison.
            It is clamped to the range "
           (math "[" "0" "," "2" "^" (var "n") "-" "1" "]")
           ",
            where "
           (math (var "n"))
           "
is the number of bitplanes in the stencil buffer. "
           (var "mask")
           " is bitwise ANDed with both the reference value
            and the stored stencil value,
            with the ANDed values participating in the comparison. ")
     (para "
If "
           (var "stencil")
           " represents the value stored in the corresponding
            stencil buffer location,
            the following list shows the effect of each comparison function
            that can be specified by "
           (var "func")
           ".
            Only if the comparison succeeds is the pixel passed through
            to the next stage in the rasterization process
            (see "
           (code "glStencilOp")
           ").
            All tests treat "
           (var "stencil")
           " values as unsigned integers in the range "
           (math "[" "0" "," "2" "^" (var "n") "-" "1" "]")
           ",
            where "
           (math (var "n"))
           "
is the number of bitplanes in the stencil buffer. ")
     (para "
The following values are accepted by "
           (var "func")
           ": ")
     (table (% (formatter (asis)))
            (entry (% (heading (code "GL_NEVER")))
                   (para "
Always fails. "))
            (entry (% (heading (code "GL_LESS")))
                   (para "
Passes if ( "
                         (var "ref")
                         " & "
                         (var "mask")
                         " ) < ( "
                         (var "stencil")
                         " & "
                         (var "mask")
                         " ). "))
            (entry (% (heading (code "GL_LEQUAL")))
                   (para "
Passes if ( "
                         (var "ref")
                         " & "
                         (var "mask")
                         " ) <= ( "
                         (var "stencil")
                         " & "
                         (var "mask")
                         " ). "))
            (entry (% (heading (code "GL_GREATER")))
                   (para "
Passes if ( "
                         (var "ref")
                         " & "
                         (var "mask")
                         " ) > ( "
                         (var "stencil")
                         " & "
                         (var "mask")
                         " ). "))
            (entry (% (heading (code "GL_GEQUAL")))
                   (para "
Passes if ( "
                         (var "ref")
                         " & "
                         (var "mask")
                         " ) >= ( "
                         (var "stencil")
                         " & "
                         (var "mask")
                         " ). "))
            (entry (% (heading (code "GL_EQUAL")))
                   (para "
Passes if ( "
                         (var "ref")
                         " & "
                         (var "mask")
                         " ) = ( "
                         (var "stencil")
                         " & "
                         (var "mask")
                         " ). "))
            (entry (% (heading (code "GL_NOTEQUAL")))
                   (para "
Passes if ( "
                         (var "ref")
                         " & "
                         (var "mask")
                         " ) != ( "
                         (var "stencil")
                         " & "
                         (var "mask")
                         " ). "))
            (entry (% (heading (code "GL_ALWAYS")))
                   (para "
Always passes. ")))
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "func")
           " is not one of the eight
            accepted values. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glStencilFunc")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glStencilMaskSeparate
  "glStencilMaskSeparate"
  (funcsynopsis
    (funcprototype
      (funcdef
        "void "
        (function "glStencilMaskSeparate"))
      (paramdef "GLenum " (parameter "face"))
      (paramdef "GLuint " (parameter "mask"))))
  '(*fragment*
     (heading
       "control the front and/or back writing of individual bits in the stencil planes")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "face")))
                   (para "
Specifies whether the front and/or back stencil writemask is updated.
                    Three symbolic constants are valid: "
                         (code "GL_FRONT")
                         ", "
                         (code "GL_BACK")
                         ", and "
                         (code "GL_FRONT_AND_BACK")
                         ". "))
            (entry (% (heading (var "mask")))
                   (para "
Specifies a bit mask to enable and disable writing of individual bits
                    in the stencil planes.
                    Initially, the mask is all 1's. ")))
     (heading "Description")
     (para (code "glStencilMaskSeparate")
           " controls the writing of individual bits in the stencil planes.
            The least significant "
           (math (var "n"))
           "
bits of "
           (var "mask")
           ",
            where "
           (math (var "n"))
           "
is the number of bits in the stencil buffer,
            specify a mask.
            Where a 1 appears in the mask,
            it's possible to write to the corresponding bit in the stencil buffer.
            Where a 0 appears,
            the corresponding bit is write-protected.
            Initially, all bits are enabled for writing. ")
     (para "
There can be two separate "
           (var "mask")
           " writemasks; one affects back-facing polygons, and the other
            affects front-facing polygons as well as other non-polygon primitives. "
           (code "glStencilMask")
           " sets both front
            and back stencil writemasks to the same values, as if "
           (code "glStencilMaskSeparate")
           " were called
            with "
           (var "face")
           " set to "
           (code "GL_FRONT_AND_BACK")
           ". ")
     (heading "Errors")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glStencilMaskSeparate")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glStencilMask
  "glStencilMask"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glStencilMask"))
      (paramdef "GLuint " (parameter "mask"))))
  '(*fragment*
     (heading
       "control the front and back writing of individual bits in the stencil planes")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "mask")))
                   (para "
Specifies a bit mask to enable and disable writing of individual bits
                    in the stencil planes.
                    Initially, the mask is all 1's. ")))
     (heading "Description")
     (para (code "glStencilMask")
           " controls the writing of individual bits in the stencil planes.
            The least significant "
           (math (var "n"))
           "
bits of "
           (var "mask")
           ",
            where "
           (math (var "n"))
           "
is the number of bits in the stencil buffer,
            specify a mask.
            Where a 1 appears in the mask,
            it's possible to write to the corresponding bit in the stencil buffer.
            Where a 0 appears,
            the corresponding bit is write-protected.
            Initially, all bits are enabled for writing. ")
     (para "
There can be two separate "
           (var "mask")
           " writemasks; one affects back-facing polygons, and the other
            affects front-facing polygons as well as other non-polygon primitives. "
           (code "glStencilMask")
           " sets both front
            and back stencil writemasks to the same values. Use "
           (code "glStencilMaskSeparate")
           "
to set front and back stencil writemasks to different values. ")
     (heading "Errors")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glStencilMask")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glStencilOpSeparate
  "glStencilOpSeparate"
  (funcsynopsis
    (funcprototype
      (funcdef
        "void "
        (function "glStencilOpSeparate"))
      (paramdef "GLenum " (parameter "face"))
      (paramdef "GLenum " (parameter "sfail"))
      (paramdef "GLenum " (parameter "dpfail"))
      (paramdef "GLenum " (parameter "dppass"))))
  '(*fragment*
     (heading
       "set front and/or back stencil test actions")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "face")))
                   (para "
Specifies whether front and/or back stencil state is updated.
                    Three symbolic constants are valid: "
                         (code "GL_FRONT")
                         ", "
                         (code "GL_BACK")
                         ", and "
                         (code "GL_FRONT_AND_BACK")
                         ". "))
            (entry (% (heading (var "sfail")))
                   (para "
Specifies the action to take when the stencil test fails.
                    Eight symbolic constants are accepted: "
                         (code "GL_KEEP")
                         ", "
                         (code "GL_ZERO")
                         ", "
                         (code "GL_REPLACE")
                         ", "
                         (code "GL_INCR")
                         ", "
                         (code "GL_INCR_WRAP")
                         ", "
                         (code "GL_DECR")
                         ", "
                         (code "GL_DECR_WRAP")
                         ", and "
                         (code "GL_INVERT")
                         ". The initial value is "
                         (code "GL_KEEP")
                         ". "))
            (entry (% (heading (var "dpfail")))
                   (para "
Specifies the stencil action when the stencil test passes,
                    but the depth test fails. "
                         (var "dpfail")
                         " accepts the same symbolic constants as "
                         (var "sfail")
                         ". The initial value
                    is "
                         (code "GL_KEEP")
                         ". "))
            (entry (% (heading (var "dppass")))
                   (para "
Specifies the stencil action when both the stencil test and the depth
                    test pass, or when the stencil test passes and either there is no
                    depth buffer or depth testing is not enabled. "
                         (var "dppass")
                         " accepts the same symbolic constants as "
                         (var "sfail")
                         ". The initial value
                    is "
                         (code "GL_KEEP")
                         ". ")))
     (heading "Description")
     (para "
Stenciling,
            like depth-buffering,
            enables and disables drawing on a per-pixel basis.
            You draw into the stencil planes using GL drawing primitives,
            then render geometry and images,
            using the stencil planes to mask out portions of the screen.
            Stenciling is typically used in multipass rendering algorithms
            to achieve special effects,
            such as decals,
            outlining,
            and constructive solid geometry rendering. ")
     (para "
The stencil test conditionally eliminates a pixel based on the outcome
            of a comparison between the value in the stencil buffer and a
            reference value. To enable and disable the test, call "
           (code "glEnable")
           "
and "
           (code "glDisable")
           " with argument "
           (code "GL_STENCIL_TEST")
           "; to control it, call "
           (code "glStencilFunc")
           " or "
           (code "glStencilFuncSeparate")
           ". ")
     (para "
There can be two separate sets of "
           (var "sfail")
           ", "
           (var "dpfail")
           ", and "
           (var "dppass")
           " parameters; one affects back-facing polygons, and the other
            affects front-facing polygons as well as other non-polygon primitives. "
           (code "glStencilOp")
           " sets both front
            and back stencil state to the same values, as if "
           (code "glStencilOpSeparate")
           " were called
            with "
           (var "face")
           " set to "
           (code "GL_FRONT_AND_BACK")
           ". ")
     (para (code "glStencilOpSeparate")
           " takes three arguments that indicate what happens
            to the stored stencil value while stenciling is enabled.
            If the stencil test fails,
            no change is made to the pixel's color or depth buffers,
            and "
           (var "sfail")
           " specifies what happens to the stencil buffer contents.
            The following eight actions are possible. ")
     (table (% (formatter (asis)))
            (entry (% (heading (code "GL_KEEP")))
                   (para "
Keeps the current value. "))
            (entry (% (heading (code "GL_ZERO")))
                   (para "
Sets the stencil buffer value to 0. "))
            (entry (% (heading (code "GL_REPLACE")))
                   (para "
Sets the stencil buffer value to "
                         (var "ref")
                         ",
                        as specified by "
                         (code "glStencilFunc")
                         ". "))
            (entry (% (heading (code "GL_INCR")))
                   (para "
Increments the current stencil buffer value.
                        Clamps to the maximum representable unsigned value. "))
            (entry (% (heading (code "GL_INCR_WRAP")))
                   (para "
Increments the current stencil buffer value.
                        Wraps stencil buffer value to zero when incrementing the maximum
                        representable unsigned value. "))
            (entry (% (heading (code "GL_DECR")))
                   (para "
Decrements the current stencil buffer value.
                        Clamps to 0. "))
            (entry (% (heading (code "GL_DECR_WRAP")))
                   (para "
Decrements the current stencil buffer value.
                        Wraps stencil buffer value to the maximum representable unsigned value when
                        decrementing a stencil buffer value of zero. "))
            (entry (% (heading (code "GL_INVERT")))
                   (para "
Bitwise inverts the current stencil buffer value. ")))
     (para "
Stencil buffer values are treated as unsigned integers.
            When incremented and decremented,
            values are clamped to 0 and "
           (math "2" "^" (var "n") "-" "1")
           ",
            where "
           (math (var "n"))
           "
is the value returned by querying "
           (code "GL_STENCIL_BITS")
           ". ")
     (para "
The other two arguments to "
           (code "glStencilOpSeparate")
           " specify stencil buffer actions
            that depend on whether subsequent depth buffer tests succeed ("
           (var "dppass")
           ")
            or fail ("
           (var "dpfail")
           ") (see "
           (code "glDepthFunc")
           ").
            The actions are specified using the same eight symbolic constants as "
           (var "sfail")
           ".
            Note that "
           (var "dpfail")
           " is ignored when there is no depth buffer,
            or when the depth buffer is not enabled.
            In these cases, "
           (var "sfail")
           " and "
           (var "dppass")
           " specify stencil action when the
            stencil test fails and passes,
            respectively. ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "face")
           " is any value 
            other than "
           (code "GL_FRONT")
           ", "
           (code "GL_BACK")
           ", or "
           (code "GL_FRONT_AND_BACK")
           ". ")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "sfail")
           ", "
           (var "dpfail")
           ", or "
           (var "dppass")
           " is any value other than the eight defined constant values. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glStencilOpSeparate")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glStencilOp
  "glStencilOp"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glStencilOp"))
      (paramdef "GLenum " (parameter "sfail"))
      (paramdef "GLenum " (parameter "dpfail"))
      (paramdef "GLenum " (parameter "dppass"))))
  '(*fragment*
     (heading
       "set front and back stencil test actions")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "sfail")))
                   (para "
Specifies the action to take when the stencil test fails.
                    Eight symbolic constants are accepted: "
                         (code "GL_KEEP")
                         ", "
                         (code "GL_ZERO")
                         ", "
                         (code "GL_REPLACE")
                         ", "
                         (code "GL_INCR")
                         ", "
                         (code "GL_INCR_WRAP")
                         ", "
                         (code "GL_DECR")
                         ", "
                         (code "GL_DECR_WRAP")
                         ", and "
                         (code "GL_INVERT")
                         ". The initial value is "
                         (code "GL_KEEP")
                         ". "))
            (entry (% (heading (var "dpfail")))
                   (para "
Specifies the stencil action when the stencil test passes,
                    but the depth test fails. "
                         (var "dpfail")
                         " accepts the same symbolic constants as "
                         (var "sfail")
                         ". The initial value
                    is "
                         (code "GL_KEEP")
                         ". "))
            (entry (% (heading (var "dppass")))
                   (para "
Specifies the stencil action when both the stencil test and the depth
                    test pass, or when the stencil test passes and either there is no
                    depth buffer or depth testing is not enabled. "
                         (var "dppass")
                         " accepts the same symbolic constants as "
                         (var "sfail")
                         ". The initial value
                    is "
                         (code "GL_KEEP")
                         ". ")))
     (heading "Description")
     (para "
Stenciling,
            like depth-buffering,
            enables and disables drawing on a per-pixel basis.
            You draw into the stencil planes using GL drawing primitives,
            then render geometry and images,
            using the stencil planes to mask out portions of the screen.
            Stenciling is typically used in multipass rendering algorithms
            to achieve special effects,
            such as decals,
            outlining,
            and constructive solid geometry rendering. ")
     (para "
The stencil test conditionally eliminates a pixel based on the outcome
            of a comparison between the value in the stencil buffer and a
            reference value. To enable and disable the test, call "
           (code "glEnable")
           "
and "
           (code "glDisable")
           " with argument "
           (code "GL_STENCIL_TEST")
           "; to control it, call "
           (code "glStencilFunc")
           " or "
           (code "glStencilFuncSeparate")
           ". ")
     (para "
There can be two separate sets of "
           (var "sfail")
           ", "
           (var "dpfail")
           ", and "
           (var "dppass")
           " parameters; one affects back-facing polygons, and the other
            affects front-facing polygons as well as other non-polygon primitives. "
           (code "glStencilOp")
           " sets both front
            and back stencil state to the same values. Use "
           (code "glStencilOpSeparate")
           "
to set front and back stencil state to different values. ")
     (para (code "glStencilOp")
           " takes three arguments that indicate what happens
            to the stored stencil value while stenciling is enabled.
            If the stencil test fails,
            no change is made to the pixel's color or depth buffers,
            and "
           (var "sfail")
           " specifies what happens to the stencil buffer contents.
            The following eight actions are possible. ")
     (table (% (formatter (asis)))
            (entry (% (heading (code "GL_KEEP")))
                   (para "
Keeps the current value. "))
            (entry (% (heading (code "GL_ZERO")))
                   (para "
Sets the stencil buffer value to 0. "))
            (entry (% (heading (code "GL_REPLACE")))
                   (para "
Sets the stencil buffer value to "
                         (var "ref")
                         ",
                        as specified by "
                         (code "glStencilFunc")
                         ". "))
            (entry (% (heading (code "GL_INCR")))
                   (para "
Increments the current stencil buffer value.
                        Clamps to the maximum representable unsigned value. "))
            (entry (% (heading (code "GL_INCR_WRAP")))
                   (para "
Increments the current stencil buffer value.
                        Wraps stencil buffer value to zero when incrementing the maximum
                        representable unsigned value. "))
            (entry (% (heading (code "GL_DECR")))
                   (para "
Decrements the current stencil buffer value.
                        Clamps to 0. "))
            (entry (% (heading (code "GL_DECR_WRAP")))
                   (para "
Decrements the current stencil buffer value.
                        Wraps stencil buffer value to the maximum representable unsigned value when
                        decrementing a stencil buffer value of zero. "))
            (entry (% (heading (code "GL_INVERT")))
                   (para "
Bitwise inverts the current stencil buffer value. ")))
     (para "
Stencil buffer values are treated as unsigned integers.
            When incremented and decremented,
            values are clamped to 0 and "
           (math "2" "^" (var "n") "-" "1")
           ",
            where "
           (math (var "n"))
           "
is the value returned by querying "
           (code "GL_STENCIL_BITS")
           ". ")
     (para "
The other two arguments to "
           (code "glStencilOp")
           " specify stencil buffer actions
            that depend on whether subsequent depth buffer tests succeed ("
           (var "dppass")
           ")
            or fail ("
           (var "dpfail")
           ") (see "
           (code "glDepthFunc")
           ").
            The actions are specified using the same eight symbolic constants as "
           (var "sfail")
           ".
            Note that "
           (var "dpfail")
           " is ignored when there is no depth buffer,
            or when the depth buffer is not enabled.
            In these cases, "
           (var "sfail")
           " and "
           (var "dppass")
           " specify stencil action when the
            stencil test fails and passes,
            respectively. ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "sfail")
           ", "
           (var "dpfail")
           ", or "
           (var "dppass")
           " is any value other than the eight defined constant values. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glStencilOp")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glTexCoordPointer
  "glTexCoordPointer"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glTexCoordPointer"))
      (paramdef "GLint " (parameter "size"))
      (paramdef "GLenum " (parameter "type"))
      (paramdef "GLsizei " (parameter "stride"))
      (paramdef
        "const GLvoid * "
        (parameter "pointer"))))
  '(*fragment*
     (heading
       "define an array of texture coordinates")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "size")))
                   (para "
Specifies the number of coordinates per array element. Must be 1, 2, 3,
                    or 4. The initial value is 4. "))
            (entry (% (heading (var "type")))
                   (para "
Specifies the data type of each texture coordinate.
                    Symbolic constants "
                         (code "GL_SHORT")
                         ", "
                         (code "GL_INT")
                         ", "
                         (code "GL_FLOAT")
                         ",
                    or "
                         (code "GL_DOUBLE")
                         "
are accepted. The initial value is "
                         (code "GL_FLOAT")
                         ". "))
            (entry (% (heading (var "stride")))
                   (para "
Specifies the byte offset between consecutive texture coordinate sets.
                    If "
                         (var "stride")
                         " is 0, the array elements are understood
                    to be tightly packed. The initial value is 0. "))
            (entry (% (heading (var "pointer")))
                   (para "
Specifies a pointer to the first coordinate of the first texture coordinate set in the
                    array. The initial value is 0. ")))
     (heading "Description")
     (para (code "glTexCoordPointer")
           " specifies the location and data format of an array of texture
            coordinates to use when rendering. "
           (var "size")
           " specifies the number of coordinates per
            texture coordinate set, and must be 1, 2, 3, or 4. "
           (var "type")
           " specifies the data type of each texture coordinate,
            and "
           (var "stride")
           " specifies the byte stride from one
            texture coordinate set to the next, allowing vertices and attributes
            to be packed into a single array or stored in separate arrays.
            (Single-array storage may be more efficient on some implementations;
            see "
           (code "glInterleavedArrays")
           ".) ")
     (para "
If a non-zero named buffer object is bound to the "
           (code "GL_ARRAY_BUFFER")
           " target 
            (see "
           (code "glBindBuffer")
           ") while a texture coordinate array is
            specified, "
           (var "pointer")
           " is treated as a byte offset into the buffer object's data store.
            Also, the buffer object binding ("
           (code "GL_ARRAY_BUFFER_BINDING")
           ") is saved as texture coordinate vertex array
            client-side state ("
           (code "GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING")
           "). ")
     (para "
When a texture coordinate array is specified, "
           (var "size")
           ", "
           (var "type")
           ", "
           (var "stride")
           ", and "
           (var "pointer")
           " are saved as client-side
            state, in addition to the current vertex array buffer object binding. ")
     (para "
To enable and disable a texture coordinate array, call "
           (code "glEnableClientState")
           " and "
           (code "glDisableClientState")
           " with the argument "
           (code "GL_TEXTURE_COORD_ARRAY")
           ". If enabled, the texture coordinate array is used when "
           (code "glArrayElement")
           ", "
           (code "glDrawArrays")
           ", "
           (code "glMultiDrawArrays")
           ", "
           (code "glDrawElements")
           ", "
           (code "glMultiDrawElements")
           ", or "
           (code "glDrawRangeElements")
           "
is called. ")
     (heading "Errors")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "size")
           " is not 1, 2, 3, or 4. ")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "type")
           " is not an accepted value. ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "stride")
           " is negative. ")))

(define-gl-procedure
  glTexCoord
  "glTexCoord"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glTexCoord1s"))
      (paramdef "GLshort " (parameter "s"))))
  '(*fragment*
     (heading "set the current texture coordinates")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "s")))
                   (itemx (var "t"))
                   (itemx (var "r"))
                   (itemx (var "q"))
                   (para "
Specify "
                         (var "s")
                         ", "
                         (var "t")
                         ", "
                         (var "r")
                         ", and "
                         (var "q")
                         " texture coordinates.
                    Not all parameters are present in all forms of the command. ")))
     (heading "Description")
     (para (code "glTexCoord")
           " specifies texture coordinates in
            one,
            two,
            three, or
            four dimensions. "
           (code "glTexCoord1")
           " sets the current texture coordinates to "
           (math "(" (var "s") "," "0" "0" "1" ")")
           ";
            a call to "
           (code "glTexCoord2")
           " sets them to "
           (math "(" (var "s") "," (var "t") "0" "1" ")")
           ".
            Similarly, "
           (code "glTexCoord3")
           " specifies the texture coordinates as "
           (math "("
                 (var "s")
                 ","
                 (var "t")
                 (var "r")
                 "1"
                 ")")
           ",
            and "
           (code "glTexCoord4")
           " defines all four components explicitly as "
           (math "("
                 (var "s")
                 ","
                 (var "t")
                 (var "r")
                 (var "q")
                 ")")
           ". ")
     (para "
The current texture coordinates are part of the data
            that is associated with each vertex and with the current
            raster position.
            Initially, the values for "
           (var "s")
           ", "
           (var "t")
           ", "
           (var "r")
           ", and "
           (var "q")
           "
are (0, 0, 0, 1). ")
     (para)))

(define-gl-procedure
  glTexEnv
  "glTexEnv"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glTexEnvf"))
      (paramdef "GLenum " (parameter "target"))
      (paramdef "GLenum " (parameter "pname"))
      (paramdef "GLfloat " (parameter "param"))))
  '(*fragment*
     (heading "set texture environment parameters")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "target")))
                   (para "
Specifies a texture environment.
                    May be "
                         (code "GL_TEXTURE_ENV")
                         ", "
                         (code "GL_TEXTURE_FILTER_CONTROL")
                         " or "
                         (code "GL_POINT_SPRITE")
                         ". "))
            (entry (% (heading (var "pname")))
                   (para "
Specifies the symbolic name of a single-valued texture environment parameter.
                    May be either "
                         (code "GL_TEXTURE_ENV_MODE")
                         ", "
                         (code "GL_TEXTURE_LOD_BIAS")
                         ", "
                         (code "GL_COMBINE_RGB")
                         ", "
                         (code "GL_COMBINE_ALPHA")
                         ", "
                         (code "GL_SRC0_RGB")
                         ", "
                         (code "GL_SRC1_RGB")
                         ", "
                         (code "GL_SRC2_RGB")
                         ", "
                         (code "GL_SRC0_ALPHA")
                         ", "
                         (code "GL_SRC1_ALPHA")
                         ", "
                         (code "GL_SRC2_ALPHA")
                         ", "
                         (code "GL_OPERAND0_RGB")
                         ", "
                         (code "GL_OPERAND1_RGB")
                         ", "
                         (code "GL_OPERAND2_RGB")
                         ", "
                         (code "GL_OPERAND0_ALPHA")
                         ", "
                         (code "GL_OPERAND1_ALPHA")
                         ", "
                         (code "GL_OPERAND2_ALPHA")
                         ", "
                         (code "GL_RGB_SCALE")
                         ", "
                         (code "GL_ALPHA_SCALE")
                         ", or "
                         (code "GL_COORD_REPLACE")
                         ". "))
            (entry (% (heading (var "param")))
                   (para "
Specifies a single symbolic constant, one of "
                         (code "GL_ADD")
                         ", "
                         (code "GL_ADD_SIGNED")
                         ", "
                         (code "GL_INTERPOLATE")
                         ", "
                         (code "GL_MODULATE")
                         ", "
                         (code "GL_DECAL")
                         ", "
                         (code "GL_BLEND")
                         ", "
                         (code "GL_REPLACE")
                         ", "
                         (code "GL_SUBTRACT")
                         ", "
                         (code "GL_COMBINE")
                         ", "
                         (code "GL_TEXTURE")
                         ", "
                         (code "GL_CONSTANT")
                         ", "
                         (code "GL_PRIMARY_COLOR")
                         ", "
                         (code "GL_PREVIOUS")
                         ", "
                         (code "GL_SRC_COLOR")
                         ", "
                         (code "GL_ONE_MINUS_SRC_COLOR")
                         ", "
                         (code "GL_SRC_ALPHA")
                         ", "
                         (code "GL_ONE_MINUS_SRC_ALPHA")
                         ",
                    a single boolean value for the point sprite texture coordinate replacement,
                    a single floating-point value for the texture level-of-detail bias,
                    or 1.0, 2.0, or 4.0 when specifying the "
                         (code "GL_RGB_SCALE")
                         " or "
                         (code "GL_ALPHA_SCALE")
                         ". ")))
     (heading "Description")
     (para "
A texture environment specifies how texture values are interpreted when a
            fragment is textured.  When "
           (var "target")
           " is "
           (code "GL_TEXTURE_FILTER_CONTROL")
           ", "
           (var "pname")
           " must be "
           (code "GL_TEXTURE_LOD_BIAS")
           ".  When "
           (var "target")
           " is "
           (code "GL_TEXTURE_ENV")
           ", "
           (var "pname")
           " can be "
           (code "GL_TEXTURE_ENV_MODE")
           ", "
           (code "GL_TEXTURE_ENV_COLOR")
           ", "
           (code "GL_COMBINE_RGB")
           ", "
           (code "GL_COMBINE_ALPHA")
           ", "
           (code "GL_RGB_SCALE")
           ", "
           (code "GL_ALPHA_SCALE")
           ", "
           (code "GL_SRC0_RGB")
           ", "
           (code "GL_SRC1_RGB")
           ", "
           (code "GL_SRC2_RGB")
           ", "
           (code "GL_SRC0_ALPHA")
           ", "
           (code "GL_SRC1_ALPHA")
           ", or "
           (code "GL_SRC2_ALPHA")
           ". ")
     (para "
If "
           (var "pname")
           " is "
           (code "GL_TEXTURE_ENV_MODE")
           ",
            then "
           (var "params")
           " is (or points to) the symbolic name of a texture function.
            Six texture functions may be specified: "
           (code "GL_ADD")
           ", "
           (code "GL_MODULATE")
           ", "
           (code "GL_DECAL")
           ", "
           (code "GL_BLEND")
           ", "
           (code "GL_REPLACE")
           ", or "
           (code "GL_COMBINE")
           ". ")
     (para "
The following table shows the correspondence of filtered texture
            values "
           (math (var "R") "_" (var "t"))
           ", "
           (math (var "G") "_" (var "t"))
           ", "
           (math (var "B") "_" (var "t"))
           ", "
           (math (var "A") "_" (var "t"))
           ", "
           (math (var "L") "_" (var "t"))
           ", "
           (math (var "I") "_" (var "t"))
           "
to texture source components. "
           (math (var "C") "_" (var "s"))
           "
and "
           (math (var "A") "_" (var "s"))
           "
are used by the texture functions described below. ")
     (para)
     (table (% (formatter (asis)))
            (entry (% (heading "
Texture Base Internal Format "))
                   (para (math (code "C") "_" (var "s"))
                         ", "
                         (math (code "A") "_" (var "s"))))
            (entry (% (heading (code "GL_ALPHA")))
                   (para "
(0, 0, 0) "
                         ", "
                         (math (var "A") "_" (var "t"))))
            (entry (% (heading (code "GL_LUMINANCE")))
                   (para "
( "
                         (math (var "L") "_" (var "t"))
                         ", "
                         (math (var "L") "_" (var "t"))
                         ", "
                         (math (var "L") "_" (var "t"))
                         "
) "
                         ", "
                         "
1 "))
            (entry (% (heading (code "GL_LUMINANCE_ALPHA")))
                   (para "
( "
                         (math (var "L") "_" (var "t"))
                         ", "
                         (math (var "L") "_" (var "t"))
                         ", "
                         (math (var "L") "_" (var "t"))
                         "
) "
                         ", "
                         (math (var "A") "_" (var "t"))))
            (entry (% (heading (code "GL_INTENSITY")))
                   (para "
( "
                         (math (var "I") "_" (var "t"))
                         ", "
                         (math (var "I") "_" (var "t"))
                         ", "
                         (math (var "I") "_" (var "t"))
                         "
) "
                         ", "
                         (math (var "I") "_" (var "t"))))
            (entry (% (heading (code "GL_RGB")))
                   (para "
( "
                         (math (var "R") "_" (var "t"))
                         ", "
                         (math (var "G") "_" (var "t"))
                         ", "
                         (math (var "B") "_" (var "t"))
                         "
) "
                         ", "
                         "
1 "))
            (entry (% (heading (code "GL_RGBA")))
                   (para "
( "
                         (math (var "R") "_" (var "t"))
                         ", "
                         (math (var "G") "_" (var "t"))
                         ", "
                         (math (var "B") "_" (var "t"))
                         "
) "
                         ", "
                         (math (var "A") "_" (var "t")))))
     (para "
A texture function acts on the fragment to be textured using
            the texture image value that applies to the fragment
            (see "
           (code "glTexParameter")
           ")
            and produces an RGBA color for that fragment.
            The following table shows how the RGBA color is produced for each
            of the first five texture functions that can be chosen. "
           (math (var "C"))
           "
is a triple of color values (RGB) and "
           (math (var "A"))
           "
is the associated alpha value.
            RGBA values extracted from a texture image are in the range [0,1].
            The subscript "
           (math (var "p"))
           "
refers to the color computed from the previous texture stage (or the incoming fragment if processing texture stage 0),
            the subscript "
           (math (var "s"))
           "
to the texture source color,
            the subscript "
           (math (var "c"))
           "
to the texture environment color,
            and the subscript "
           (math (var "v"))
           "
indicates a value produced by the texture function. ")
     (para)
     (table (% (formatter (asis)))
            (entry (% (heading "
Texture Base Internal Format "))
                   (para (code "Value")
                         ", "
                         (code "GL_REPLACE")
                         " Function "
                         ", "
                         (code "GL_MODULATE")
                         " Function "
                         ", "
                         (code "GL_DECAL")
                         " Function "
                         ", "
                         (code "GL_BLEND")
                         " Function "
                         ", "
                         (code "GL_ADD")
                         " Function "))
            (entry (% (heading (code "GL_ALPHA")))
                   (para (math (var "C") "_" (var "v") "=")
                         ", "
                         (math (var "C") "_" (var "p"))
                         ", "
                         (math (var "C") "_" (var "p"))
                         ", "
                         "
undefined "
                         ", "
                         (math (var "C") "_" (var "p"))
                         ", "
                         (math (var "C") "_" (var "p"))))
            (entry (% (heading))
                   (para (math (var "A") "_" (var "v") "=")
                         ", "
                         (math (var "A") "_" (var "s"))
                         ", "
                         (math (var "A")
                               "_"
                               (var "p")
                               "\u2062"
                               (var "A")
                               "_"
                               (var "s"))
                         ", "
                         ", "
                         (math (var "A")
                               "_"
                               (var "v")
                               "="
                               (var "A")
                               "_"
                               (var "p")
                               "\u2062"
                               (var "A")
                               "_"
                               (var "s"))
                         ", "
                         (math (var "A")
                               "_"
                               (var "p")
                               "\u2062"
                               (var "A")
                               "_"
                               (var "s"))))
            (entry (% (heading (code "GL_LUMINANCE")))
                   (para (math (var "C") "_" (var "v") "=")
                         ", "
                         (math (var "C") "_" (var "s"))
                         ", "
                         (math (var "C")
                               "_"
                               (var "p")
                               "\u2062"
                               (var "C")
                               "_"
                               (var "s"))
                         ", "
                         "
undefined "
                         ", "
                         (math (var "C")
                               "_"
                               (var "p")
                               "\u2062"
                               "("
                               "1"
                               "-"
                               (var "C")
                               "_"
                               (var "s")
                               ","
                               ")"
                               "+"
                               (var "C")
                               "_"
                               (var "c")
                               "\u2062"
                               (var "C")
                               "_"
                               (var "s"))
                         ", "
                         (math (var "C")
                               "_"
                               (var "p")
                               "+"
                               (var "C")
                               "_"
                               (var "s"))))
            (entry (% (heading "
(or 1) "))
                   (para (math (var "A") "_" (var "v") "=")
                         ", "
                         (math (var "A") "_" (var "p"))
                         ", "
                         (math (var "A") "_" (var "p"))
                         ", "
                         ", "
                         (math (var "A") "_" (var "p"))
                         ", "
                         (math (var "A") "_" (var "p"))))
            (entry (% (heading (code "GL_LUMINANCE_ALPHA")))
                   (para (math (var "C") "_" (var "v") "=")
                         ", "
                         (math (var "C") "_" (var "s"))
                         ", "
                         (math (var "C")
                               "_"
                               (var "p")
                               "\u2062"
                               (var "C")
                               "_"
                               (var "s"))
                         ", "
                         "
undefined "
                         ", "
                         (math (var "C")
                               "_"
                               (var "p")
                               "\u2062"
                               "("
                               "1"
                               "-"
                               (var "C")
                               "_"
                               (var "s")
                               ","
                               ")"
                               "+"
                               (var "C")
                               "_"
                               (var "c")
                               "\u2062"
                               (var "C")
                               "_"
                               (var "s"))
                         ", "
                         (math (var "C")
                               "_"
                               (var "p")
                               "+"
                               (var "C")
                               "_"
                               (var "s"))))
            (entry (% (heading "
(or 2) "))
                   (para (math (var "A") "_" (var "v") "=")
                         ", "
                         (math (var "A") "_" (var "s"))
                         ", "
                         (math (var "A")
                               "_"
                               (var "p")
                               "\u2062"
                               (var "A")
                               "_"
                               (var "s"))
                         ", "
                         ", "
                         (math (var "A")
                               "_"
                               (var "p")
                               "\u2062"
                               (var "A")
                               "_"
                               (var "s"))
                         ", "
                         (math (var "A")
                               "_"
                               (var "p")
                               "\u2062"
                               (var "A")
                               "_"
                               (var "s"))))
            (entry (% (heading (code "GL_INTENSITY")))
                   (para (math (var "C") "_" (var "v") "=")
                         ", "
                         (math (var "C") "_" (var "s"))
                         ", "
                         (math (var "C")
                               "_"
                               (var "p")
                               "\u2062"
                               (var "C")
                               "_"
                               (var "s"))
                         ", "
                         "
undefined "
                         ", "
                         (math (var "C")
                               "_"
                               (var "p")
                               "\u2062"
                               "("
                               "1"
                               "-"
                               (var "C")
                               "_"
                               (var "s")
                               ","
                               ")"
                               "+"
                               (var "C")
                               "_"
                               (var "c")
                               "\u2062"
                               (var "C")
                               "_"
                               (var "s"))
                         ", "
                         (math (var "C")
                               "_"
                               (var "p")
                               "+"
                               (var "C")
                               "_"
                               (var "s"))))
            (entry (% (heading))
                   (para (math (var "A") "_" (var "v") "=")
                         ", "
                         (math (var "A") "_" (var "s"))
                         ", "
                         (math (var "A")
                               "_"
                               (var "p")
                               "\u2062"
                               (var "A")
                               "_"
                               (var "s"))
                         ", "
                         ", "
                         (math (var "A")
                               "_"
                               (var "p")
                               "\u2062"
                               "("
                               "1"
                               "-"
                               (var "A")
                               "_"
                               (var "s")
                               ","
                               ")"
                               "+"
                               (var "A")
                               "_"
                               (var "c")
                               "\u2062"
                               (var "A")
                               "_"
                               (var "s"))
                         ", "
                         (math (var "A")
                               "_"
                               (var "p")
                               "+"
                               (var "A")
                               "_"
                               (var "s"))))
            (entry (% (heading (code "GL_RGB")))
                   (para (math (var "C") "_" (var "v") "=")
                         ", "
                         (math (var "C") "_" (var "s"))
                         ", "
                         (math (var "C")
                               "_"
                               (var "p")
                               "\u2062"
                               (var "C")
                               "_"
                               (var "s"))
                         ", "
                         (math (var "C") "_" (var "s"))
                         ", "
                         (math (var "C")
                               "_"
                               (var "p")
                               "\u2062"
                               "("
                               "1"
                               "-"
                               (var "C")
                               "_"
                               (var "s")
                               ","
                               ")"
                               "+"
                               (var "C")
                               "_"
                               (var "c")
                               "\u2062"
                               (var "C")
                               "_"
                               (var "s"))
                         ", "
                         (math (var "C")
                               "_"
                               (var "p")
                               "+"
                               (var "C")
                               "_"
                               (var "s"))))
            (entry (% (heading "
(or 3) "))
                   (para (math (var "A") "_" (var "v") "=")
                         ", "
                         (math (var "A") "_" (var "p"))
                         ", "
                         (math (var "A") "_" (var "p"))
                         ", "
                         (math (var "A") "_" (var "p"))
                         ", "
                         (math (var "A") "_" (var "p"))
                         ", "
                         (math (var "A") "_" (var "p"))))
            (entry (% (heading (code "GL_RGBA")))
                   (para (math (var "C") "_" (var "v") "=")
                         ", "
                         (math (var "C") "_" (var "s"))
                         ", "
                         (math (var "C")
                               "_"
                               (var "p")
                               "\u2062"
                               (var "C")
                               "_"
                               (var "s"))
                         ", "
                         (math (var "C")
                               "_"
                               (var "p")
                               "\u2062"
                               "("
                               "1"
                               "-"
                               (var "A")
                               "_"
                               (var "s")
                               ","
                               ")"
                               "+"
                               (var "C")
                               "_"
                               (var "s")
                               "\u2062"
                               (var "A")
                               "_"
                               (var "s"))
                         ", "
                         (math (var "C")
                               "_"
                               (var "p")
                               "\u2062"
                               "("
                               "1"
                               "-"
                               (var "C")
                               "_"
                               (var "s")
                               ","
                               ")"
                               "+"
                               (var "C")
                               "_"
                               (var "c")
                               "\u2062"
                               (var "C")
                               "_"
                               (var "s"))
                         ", "
                         (math (var "C")
                               "_"
                               (var "p")
                               "+"
                               (var "C")
                               "_"
                               (var "s"))))
            (entry (% (heading "
(or 4) "))
                   (para (math (var "A") "_" (var "v") "=")
                         ", "
                         (math (var "A") "_" (var "s"))
                         ", "
                         (math (var "A")
                               "_"
                               (var "p")
                               "\u2062"
                               (var "A")
                               "_"
                               (var "s"))
                         ", "
                         (math (var "A") "_" (var "p"))
                         ", "
                         (math (var "A")
                               "_"
                               (var "p")
                               "\u2062"
                               (var "A")
                               "_"
                               (var "s"))
                         ", "
                         (math (var "A")
                               "_"
                               (var "p")
                               "\u2062"
                               (var "A")
                               "_"
                               (var "s")))))
     (para "
If "
           (var "pname")
           " is "
           (code "GL_TEXTURE_ENV_MODE")
           ", and "
           (var "params")
           " is "
           (code "GL_COMBINE")
           ", the
            form of the texture function depends on the values of "
           (code "GL_COMBINE_RGB")
           "
and "
           (code "GL_COMBINE_ALPHA")
           ". ")
     (para "
The following describes how the texture sources, as specified by "
           (code "GL_SRC0_RGB")
           ", "
           (code "GL_SRC1_RGB")
           ", "
           (code "GL_SRC2_RGB")
           ", "
           (code "GL_SRC0_ALPHA")
           ", "
           (code "GL_SRC1_ALPHA")
           ", and "
           (code "GL_SRC2_ALPHA")
           ",
            are combined to produce a final texture color. In the following tables, "
           (code "GL_SRC0_c")
           " is represented by "
           (math (var "Arg0"))
           ", "
           (code "GL_SRC1_c")
           " is
            represented by "
           (math (var "Arg1"))
           ",
            and "
           (code "GL_SRC2_c")
           " is represented by "
           (math (var "Arg2"))
           ". ")
     (para (code "GL_COMBINE_RGB")
           " accepts any of "
           (code "GL_REPLACE")
           ", "
           (code "GL_MODULATE")
           ", "
           (code "GL_ADD")
           ", "
           (code "GL_ADD_SIGNED")
           ", "
           (code "GL_INTERPOLATE")
           ", "
           (code "GL_SUBTRACT")
           ", "
           (code "GL_DOT3_RGB")
           ", or "
           (code "GL_DOT3_RGBA")
           ". ")
     (para)
     (table (% (formatter (asis)))
            (entry (% (heading (strong (code "GL_COMBINE_RGB"))))
                   (para (strong "Texture Function")))
            (entry (% (heading (code "GL_REPLACE")))
                   (para (math (var "Arg0"))))
            (entry (% (heading (code "GL_MODULATE")))
                   (para (math (var "Arg0") "×" (var "Arg1"))))
            (entry (% (heading (code "GL_ADD")))
                   (para (math (var "Arg0") "+" (var "Arg1"))))
            (entry (% (heading (code "GL_ADD_SIGNED")))
                   (para (math (var "Arg0") "+" (var "Arg1") "-" "0.5")))
            (entry (% (heading (code "GL_INTERPOLATE")))
                   (para (math (var "Arg0")
                               "×"
                               (var "Arg2")
                               "+"
                               (var "Arg1")
                               "×"
                               "("
                               "1"
                               "-"
                               (var "Arg2")
                               ","
                               ")")))
            (entry (% (heading (code "GL_SUBTRACT")))
                   (para (math (var "Arg0") "-" (var "Arg1"))))
            (entry (% (heading
                        (code "GL_DOT3_RGB")
                        "
or "
                        (code "GL_DOT3_RGBA")))
                   (para (math "4"
                               "×"
                               "("
                               "("
                               "("
                               (var "Arg0")
                               "_"
                               (var "r")
                               ","
                               "-"
                               "0.5"
                               ","
                               ")"
                               "×"
                               "("
                               (var "Arg1")
                               "_"
                               (var "r")
                               ","
                               "-"
                               "0.5"
                               ","
                               ")"
                               ","
                               ")"
                               "+"
                               "("
                               "("
                               (var "Arg0")
                               "_"
                               (var "g")
                               ","
                               "-"
                               "0.5"
                               ","
                               ")"
                               "×"
                               "("
                               (var "Arg1")
                               "_"
                               (var "g")
                               ","
                               "-"
                               "0.5"
                               ","
                               ")"
                               ","
                               ")"
                               "+"
                               "("
                               "("
                               (var "Arg0")
                               "_"
                               (var "b")
                               ","
                               "-"
                               "0.5"
                               ","
                               ")"
                               "×"
                               "("
                               (var "Arg1")
                               "_"
                               (var "b")
                               ","
                               "-"
                               "0.5"
                               ","
                               ")"
                               ","
                               ")"
                               ","
                               ")"))))
     (para "
The scalar results for "
           (code "GL_DOT3_RGB")
           " and "
           (code "GL_DOT3_RGBA")
           " are placed
            into each of the 3 (RGB) or 4 (RGBA) components on output. ")
     (para "
Likewise, "
           (code "GL_COMBINE_ALPHA")
           " accepts any of "
           (code "GL_REPLACE")
           ", "
           (code "GL_MODULATE")
           ", "
           (code "GL_ADD")
           ", "
           (code "GL_ADD_SIGNED")
           ", "
           (code "GL_INTERPOLATE")
           ", or "
           (code "GL_SUBTRACT")
           ".  The following table describes how alpha values are
            combined: ")
     (para)
     (table (% (formatter (asis)))
            (entry (% (heading (strong (code "GL_COMBINE_ALPHA"))))
                   (para (strong "Texture Function")))
            (entry (% (heading (code "GL_REPLACE")))
                   (para (math (var "Arg0"))))
            (entry (% (heading (code "GL_MODULATE")))
                   (para (math (var "Arg0") "×" (var "Arg1"))))
            (entry (% (heading (code "GL_ADD")))
                   (para (math (var "Arg0") "+" (var "Arg1"))))
            (entry (% (heading (code "GL_ADD_SIGNED")))
                   (para (math (var "Arg0") "+" (var "Arg1") "-" "0.5")))
            (entry (% (heading (code "GL_INTERPOLATE")))
                   (para (math (var "Arg0")
                               "×"
                               (var "Arg2")
                               "+"
                               (var "Arg1")
                               "×"
                               "("
                               "1"
                               "-"
                               (var "Arg2")
                               ","
                               ")")))
            (entry (% (heading (code "GL_SUBTRACT")))
                   (para (math (var "Arg0") "-" (var "Arg1")))))
     (para "
In the following tables, the value "
           (math (var "C") "_" (var "s"))
           "
represents the color sampled
            from the currently bound texture, "
           (math (var "C") "_" (var "c"))
           "
represents the constant
            texture-environment color, "
           (math (var "C") "_" (var "f"))
           "
represents the primary color of the
            incoming fragment, and "
           (math (var "C") "_" (var "p"))
           "
represents the color computed from the
            previous texture stage or "
           (math (var "C") "_" (var "f"))
           "
if processing texture stage 0.  Likewise, "
           (math (var "A") "_" (var "s"))
           ", "
           (math (var "A") "_" (var "c"))
           ", "
           (math (var "A") "_" (var "f"))
           ",
            and "
           (math (var "A") "_" (var "p"))
           "
represent the respective
            alpha values. ")
     (para "
The following table describes the values assigned to "
           (math (var "Arg0"))
           ", "
           (math (var "Arg1"))
           ",
            and "
           (math (var "Arg2"))
           "
based upon the RGB sources and operands: ")
     (para)
     (table (% (formatter (asis)))
            (entry (% (heading (strong (code "GL_SRCn_RGB"))))
                   (para (strong (code "GL_OPERANDn_RGB"))
                         ", "
                         (strong "Argument Value")))
            (entry (% (heading (code "GL_TEXTURE")))
                   (para (code "GL_SRC_COLOR")
                         ", "
                         (math (var "C") "_" (var "s") ",")))
            (entry (% (heading))
                   (para (code "GL_ONE_MINUS_SRC_COLOR")
                         ", "
                         (math "1" "-" (var "C") "_" (var "s") ",")))
            (entry (% (heading))
                   (para (code "GL_SRC_ALPHA")
                         ", "
                         (math (var "A") "_" (var "s") ",")))
            (entry (% (heading))
                   (para (code "GL_ONE_MINUS_SRC_ALPHA")
                         ", "
                         (math "1" "-" (var "A") "_" (var "s") ",")))
            (entry (% (heading (code "GL_TEXTUREn")))
                   (para (code "GL_SRC_COLOR")
                         ", "
                         (math (var "C") "_" (var "s") ",")))
            (entry (% (heading))
                   (para (code "GL_ONE_MINUS_SRC_COLOR")
                         ", "
                         (math "1" "-" (var "C") "_" (var "s") ",")))
            (entry (% (heading))
                   (para (code "GL_SRC_ALPHA")
                         ", "
                         (math (var "A") "_" (var "s") ",")))
            (entry (% (heading))
                   (para (code "GL_ONE_MINUS_SRC_ALPHA")
                         ", "
                         (math "1" "-" (var "A") "_" (var "s") ",")))
            (entry (% (heading (code "GL_CONSTANT")))
                   (para (code "GL_SRC_COLOR")
                         ", "
                         (math (var "C") "_" (var "c") ",")))
            (entry (% (heading))
                   (para (code "GL_ONE_MINUS_SRC_COLOR")
                         ", "
                         (math "1" "-" (var "C") "_" (var "c") ",")))
            (entry (% (heading))
                   (para (code "GL_SRC_ALPHA")
                         ", "
                         (math (var "A") "_" (var "c") ",")))
            (entry (% (heading))
                   (para (code "GL_ONE_MINUS_SRC_ALPHA")
                         ", "
                         (math "1" "-" (var "A") "_" (var "c") ",")))
            (entry (% (heading (code "GL_PRIMARY_COLOR")))
                   (para (code "GL_SRC_COLOR")
                         ", "
                         (math (var "C") "_" (var "f") ",")))
            (entry (% (heading))
                   (para (code "GL_ONE_MINUS_SRC_COLOR")
                         ", "
                         (math "1" "-" (var "C") "_" (var "f") ",")))
            (entry (% (heading))
                   (para (code "GL_SRC_ALPHA")
                         ", "
                         (math (var "A") "_" (var "f") ",")))
            (entry (% (heading))
                   (para (code "GL_ONE_MINUS_SRC_ALPHA")
                         ", "
                         (math "1" "-" (var "A") "_" (var "f") ",")))
            (entry (% (heading (code "GL_PREVIOUS")))
                   (para (code "GL_SRC_COLOR")
                         ", "
                         (math (var "C") "_" (var "p") ",")))
            (entry (% (heading))
                   (para (code "GL_ONE_MINUS_SRC_COLOR")
                         ", "
                         (math "1" "-" (var "C") "_" (var "p") ",")))
            (entry (% (heading))
                   (para (code "GL_SRC_ALPHA")
                         ", "
                         (math (var "A") "_" (var "p") ",")))
            (entry (% (heading))
                   (para (code "GL_ONE_MINUS_SRC_ALPHA")
                         ", "
                         (math "1" "-" (var "A") "_" (var "p") ","))))
     (para "
For "
           (code "GL_TEXTUREn")
           " sources, "
           (math (var "C") "_" (var "s"))
           "
and "
           (math (var "A") "_" (var "s"))
           "
represent the color
            and alpha, respectively, produced from texture stage "
           (math (var "n"))
           ". ")
     (para "
The follow table describes the values assigned to "
           (math (var "Arg0"))
           ", "
           (math (var "Arg1"))
           ",
            and "
           (math (var "Arg2"))
           "
based upon the alpha sources and operands: ")
     (para)
     (table (% (formatter (asis)))
            (entry (% (heading (strong (code "GL_SRCn_ALPHA"))))
                   (para (strong (code "GL_OPERANDn_ALPHA"))
                         ", "
                         (strong "Argument Value")))
            (entry (% (heading (code "GL_TEXTURE")))
                   (para (code "GL_SRC_ALPHA")
                         ", "
                         (math (var "A") "_" (var "s") ",")))
            (entry (% (heading))
                   (para (code "GL_ONE_MINUS_SRC_ALPHA")
                         ", "
                         (math "1" "-" (var "A") "_" (var "s") ",")))
            (entry (% (heading (code "GL_TEXTUREn")))
                   (para (code "GL_SRC_ALPHA")
                         ", "
                         (math (var "A") "_" (var "s") ",")))
            (entry (% (heading))
                   (para (code "GL_ONE_MINUS_SRC_ALPHA")
                         ", "
                         (math "1" "-" (var "A") "_" (var "s") ",")))
            (entry (% (heading (code "GL_CONSTANT")))
                   (para (code "GL_SRC_ALPHA")
                         ", "
                         (math (var "A") "_" (var "c") ",")))
            (entry (% (heading))
                   (para (code "GL_ONE_MINUS_SRC_ALPHA")
                         ", "
                         (math "1" "-" (var "A") "_" (var "c") ",")))
            (entry (% (heading (code "GL_PRIMARY_COLOR")))
                   (para (code "GL_SRC_ALPHA")
                         ", "
                         (math (var "A") "_" (var "f") ",")))
            (entry (% (heading))
                   (para (code "GL_ONE_MINUS_SRC_ALPHA")
                         ", "
                         (math "1" "-" (var "A") "_" (var "f") ",")))
            (entry (% (heading (code "GL_PREVIOUS")))
                   (para (code "GL_SRC_ALPHA")
                         ", "
                         (math (var "A") "_" (var "p") ",")))
            (entry (% (heading))
                   (para (code "GL_ONE_MINUS_SRC_ALPHA")
                         ", "
                         (math "1" "-" (var "A") "_" (var "p") ","))))
     (para "
The RGB and alpha results of the texture function are multipled by the
            values of "
           (code "GL_RGB_SCALE")
           " and "
           (code "GL_ALPHA_SCALE")
           ", respectively, and
            clamped to the range "
           (math "[" "0" "," "1" "]")
           ". ")
     (para "
If "
           (var "pname")
           " is "
           (code "GL_TEXTURE_ENV_COLOR")
           ", "
           (var "params")
           " is a pointer to an array that holds an RGBA color consisting of four
            values.
            Integer color components are interpreted linearly such that the most
            positive integer maps to 1.0,
            and the most negative integer maps to -1.0.
            The values are clamped to the range [0,1] when they are specified. "
           (math (var "C") "_" (var "c"))
           "
takes these four values. ")
     (para "
If "
           (var "pname")
           " is "
           (code "GL_TEXTURE_LOD_BIAS")
           ", the value specified is added to the
            texture level-of-detail parameter, that selects which mipmap, or mipmaps
            depending upon the selected "
           (code "GL_TEXTURE_MIN_FILTER")
           ", will be sampled. ")
     (para (code "GL_TEXTURE_ENV_MODE")
           " defaults to "
           (code "GL_MODULATE")
           " and "
           (code "GL_TEXTURE_ENV_COLOR")
           " defaults to (0, 0, 0, 0). ")
     (para "
If "
           (var "target")
           " is "
           (code "GL_POINT_SPRITE")
           " and "
           (var "pname")
           " is "
           (code "GL_COORD_REPLACE")
           ", the boolean value specified
            is used to either enable or disable point sprite texture coordinate replacement. The default value is "
           (code "GL_FALSE")
           ". ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated when "
           (var "target")
           " or "
           (var "pname")
           " is not
            one of the accepted defined values,
            or when "
           (var "params")
           " should have a defined constant value
            (based on the value of "
           (var "pname")
           ")
            and does not. ")
     (para (code "GL_INVALID_VALUE")
           " is generated if the "
           (var "params")
           " value for "
           (code "GL_RGB_SCALE")
           " or "
           (code "GL_ALPHA_SCALE")
           " are not one of 1.0, 2.0,
            or 4.0. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glTexEnv")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glTexGen
  "glTexGen"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glTexGeni"))
      (paramdef "GLenum " (parameter "coord"))
      (paramdef "GLenum " (parameter "pname"))
      (paramdef "GLint " (parameter "param"))))
  '(*fragment*
     (heading
       "control the generation of texture coordinates")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "coord")))
                   (para "
Specifies a texture coordinate.
                    Must be one of "
                         (code "GL_S")
                         ", "
                         (code "GL_T")
                         ", "
                         (code "GL_R")
                         ", or "
                         (code "GL_Q")
                         ". "))
            (entry (% (heading (var "pname")))
                   (para "
Specifies the symbolic name of the texture-coordinate generation function.
                    Must be "
                         (code "GL_TEXTURE_GEN_MODE")
                         ". "))
            (entry (% (heading (var "param")))
                   (para "
Specifies a single-valued texture generation parameter,
                    one of "
                         (code "GL_OBJECT_LINEAR")
                         ", "
                         (code "GL_EYE_LINEAR")
                         ", "
                         (code "GL_SPHERE_MAP")
                         ", "
                         (code "GL_NORMAL_MAP")
                         ", or "
                         (code "GL_REFLECTION_MAP")
                         ". ")))
     (heading "Description")
     (para (code "glTexGen")
           " selects a texture-coordinate generation function
            or supplies coefficients for one of the functions. "
           (var "coord")
           " names one of the ("
           (var "s")
           ", "
           (var "t")
           ", "
           (var "r")
           ", "
           (var "q")
           ") texture
            coordinates; it must be one of the symbols "
           (code "GL_S")
           ", "
           (code "GL_T")
           ", "
           (code "GL_R")
           ", or "
           (code "GL_Q")
           ". "
           (var "pname")
           " must be one of three symbolic constants: "
           (code "GL_TEXTURE_GEN_MODE")
           ", "
           (code "GL_OBJECT_PLANE")
           ", or "
           (code "GL_EYE_PLANE")
           ".
            If "
           (var "pname")
           " is "
           (code "GL_TEXTURE_GEN_MODE")
           ",
            then "
           (var "params")
           " chooses a mode,
            one of "
           (code "GL_OBJECT_LINEAR")
           ", "
           (code "GL_EYE_LINEAR")
           ", "
           (code "GL_SPHERE_MAP")
           ", "
           (code "GL_NORMAL_MAP")
           ", or "
           (code "GL_REFLECTION_MAP")
           ".
            If "
           (var "pname")
           " is either "
           (code "GL_OBJECT_PLANE")
           " or "
           (code "GL_EYE_PLANE")
           ", "
           (var "params")
           " contains coefficients for the corresponding
            texture generation function. ")
     (para "
If the texture generation function is "
           (code "GL_OBJECT_LINEAR")
           ",
            the function ")
     (para (math (var "g")
                 "="
                 (var "p")
                 "_"
                 "1"
                 "×"
                 (var "x")
                 "_"
                 (var "o")
                 "+"
                 (var "p")
                 "_"
                 "2"
                 "×"
                 (var "y")
                 "_"
                 (var "o")
                 "+"
                 (var "p")
                 "_"
                 "3"
                 "×"
                 (var "z")
                 "_"
                 (var "o")
                 "+"
                 (var "p")
                 "_"
                 "4"
                 "×"
                 (var "w")
                 "_"
                 (var "o")))
     (para "
is used, where "
           (math (var "g"))
           "
is the value computed for the coordinate named in "
           (var "coord")
           ", "
           (math (var "p") "_" "1")
           ", "
           (math (var "p") "_" "2")
           ", "
           (math (var "p") "_" "3")
           ",
            and "
           (math (var "p") "_" "4")
           "
are the four values supplied in "
           (var "params")
           ", and "
           (math (var "x") "_" (var "o"))
           ", "
           (math (var "y") "_" (var "o"))
           ", "
           (math (var "z") "_" (var "o"))
           ",
            and "
           (math (var "w") "_" (var "o"))
           "
are the object coordinates of the vertex.
            This function can be used, for example, to texture-map terrain using sea level
            as a reference plane
            (defined by "
           (math (var "p") "_" "1")
           ", "
           (math (var "p") "_" "2")
           ", "
           (math (var "p") "_" "3")
           ",
            and "
           (math (var "p") "_" "4")
           ").
            The altitude of a terrain vertex is computed by the "
           (code "GL_OBJECT_LINEAR")
           "
coordinate generation function as its distance from sea level;
            that altitude can then be used to index the texture image to map white snow
            onto peaks and green grass onto foothills. ")
     (para "
If the texture generation function is "
           (code "GL_EYE_LINEAR")
           ", the function ")
     (para (math (var "g")
                 "="
                 (var "p")
                 "_"
                 "1"
                 ","
                 "^"
                 "″"
                 "×"
                 (var "x")
                 "_"
                 (var "e")
                 "+"
                 (var "p")
                 "_"
                 "2"
                 ","
                 "^"
                 "″"
                 "×"
                 (var "y")
                 "_"
                 (var "e")
                 "+"
                 (var "p")
                 "_"
                 "3"
                 ","
                 "^"
                 "″"
                 "×"
                 (var "z")
                 "_"
                 (var "e")
                 "+"
                 (var "p")
                 "_"
                 "4"
                 ","
                 "^"
                 "″"
                 "×"
                 (var "w")
                 "_"
                 (var "e")))
     (para "
is used, where ")
     (para (math "("
                 (var "p")
                 "_"
                 "1"
                 ","
                 "^"
                 "″"
                 "\u2062"
                 (var "p")
                 "_"
                 "2"
                 ","
                 "^"
                 "″"
                 "\u2062"
                 (var "p")
                 "_"
                 "3"
                 ","
                 "^"
                 "″"
                 "\u2062"
                 (var "p")
                 "_"
                 "4"
                 ","
                 "^"
                 "″"
                 ","
                 ")"
                 "="
                 "("
                 (var "p")
                 "_"
                 "1"
                 "\u2062"
                 (var "p")
                 "_"
                 "2"
                 "\u2062"
                 (var "p")
                 "_"
                 "3"
                 "\u2062"
                 (var "p")
                 "_"
                 "4"
                 ","
                 ")"
                 "\u2062"
                 (var "M")
                 "^"
                 "-1"))
     (para "
and "
           (math (var "x") "_" (var "e"))
           ", "
           (math (var "y") "_" (var "e"))
           ", "
           (math (var "z") "_" (var "e"))
           ",
            and "
           (math (var "w") "_" (var "e"))
           "
are the eye coordinates of the vertex, "
           (math (var "p") "_" "1")
           ", "
           (math (var "p") "_" "2")
           ", "
           (math (var "p") "_" "3")
           ",
            and "
           (math (var "p") "_" "4")
           "
are the values supplied in "
           (var "params")
           ", and "
           (math (var "M"))
           "
is the modelview matrix when "
           (code "glTexGen")
           " is invoked.
            If "
           (math (var "M"))
           "
is poorly conditioned or singular,
            texture coordinates generated by the resulting function may be inaccurate
            or undefined. ")
     (para "
Note that the values in "
           (var "params")
           " define a reference plane in eye coordinates.
            The modelview matrix that is applied to them may not be the same one
            in effect when the polygon vertices are transformed.
            This function establishes a field of texture coordinates
            that can produce dynamic contour lines on moving objects. ")
     (para "
If the texture generation function is "
           (code "GL_SPHERE_MAP")
           " and "
           (var "coord")
           " is either "
           (code "GL_S")
           " or "
           (code "GL_T")
           ", "
           (math (var "s"))
           "
and "
           (math (var "t"))
           "
texture coordinates are generated as follows.
            Let "
           (var "u")
           " be the unit vector pointing from the origin to the polygon vertex
            (in eye coordinates).
            Let "
           (var "n")
           " sup prime be the current normal,
            after transformation to eye coordinates.
            Let ")
     (para (math (var "f")
                 "="
                 "("
                 (var "f")
                 "_"
                 (var "x")
                 "\u2062"
                 (var "f")
                 "_"
                 (var "y")
                 "\u2062"
                 (var "f")
                 "_"
                 (var "z")
                 ","
                 ")"
                 "^"
                 (var "T"))
           "
be the reflection vector such that ")
     (para (math (var "f")
                 "="
                 (var "u")
                 "-"
                 "2"
                 "\u2062"
                 (var "n")
                 "^"
                 "″"
                 "\u2062"
                 (var "n")
                 "^"
                 "″"
                 ","
                 "^"
                 (var "T")
                 "\u2062"
                 (var "u")))
     (para "
Finally, let "
           (math (var "m")
                 "="
                 "2"
                 "\u2062"
                 "√"
                 "("
                 (var "f")
                 "_"
                 (var "x")
                 ","
                 "^"
                 "2"
                 "+"
                 (var "f")
                 "_"
                 (var "y")
                 ","
                 "^"
                 "2"
                 "+"
                 "("
                 (var "f")
                 "_"
                 (var "z")
                 "+"
                 "1"
                 ","
                 ")"
                 "^"
                 "2"
                 ","
                 ")")
           ".
            Then the values assigned to the "
           (math (var "s"))
           "
and "
           (math (var "t"))
           "
texture coordinates are ")
     (para (math (var "s")
                 "="
                 (var "f")
                 "_"
                 (var "x")
                 "/"
                 (var "m")
                 "+"
                 "1"
                 "/"
                 "2"))
     (para (math (var "t")
                 "="
                 (var "f")
                 "_"
                 (var "y")
                 "/"
                 (var "m")
                 "+"
                 "1"
                 "/"
                 "2"))
     (para "
To enable or disable a texture-coordinate generation function, call "
           (code "glEnable")
           " or "
           (code "glDisable")
           "
with one of the symbolic texture-coordinate names
            ("
           (code "GL_TEXTURE_GEN_S")
           ", "
           (code "GL_TEXTURE_GEN_T")
           ", "
           (code "GL_TEXTURE_GEN_R")
           ", or "
           (code "GL_TEXTURE_GEN_Q")
           ") as the argument.
            When enabled,
            the specified texture coordinate is computed
            according to the generating function associated with that coordinate.
            When disabled,
            subsequent vertices take the specified texture coordinate
            from the current set of texture coordinates. Initially, all texture
            generation functions are set to "
           (code "GL_EYE_LINEAR")
           " and are disabled.
            Both "
           (math (var "s"))
           "
plane equations are (1, 0, 0, 0),
            both "
           (math (var "t"))
           "
plane equations are (0, 1, 0, 0),
            and all "
           (math (var "r"))
           "
and "
           (math (var "q"))
           "
plane equations are (0, 0, 0, 0). ")
     (para "
When the "
           (code "ARB_multitexture")
           " extension is supported, "
           (code "glTexGen")
           " sets the
            texture generation parameters for the currently active texture unit,
            selected with "
           (code "glActiveTexture")
           ". ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated when "
           (var "coord")
           " or "
           (var "pname")
           " is not an
            accepted defined value,
            or when "
           (var "pname")
           " is "
           (code "GL_TEXTURE_GEN_MODE")
           " and "
           (var "params")
           " is not an
            accepted defined value. ")
     (para (code "GL_INVALID_ENUM")
           " is generated when "
           (var "pname")
           " is "
           (code "GL_TEXTURE_GEN_MODE")
           ", "
           (var "params")
           " is "
           (code "GL_SPHERE_MAP")
           ",
            and "
           (var "coord")
           " is either "
           (code "GL_R")
           " or "
           (code "GL_Q")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glTexGen")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glTexImage1D
  "glTexImage1D"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glTexImage1D"))
      (paramdef "GLenum " (parameter "target"))
      (paramdef "GLint " (parameter "level"))
      (paramdef "GLint " (parameter "internalFormat"))
      (paramdef "GLsizei " (parameter "width"))
      (paramdef "GLint " (parameter "border"))
      (paramdef "GLenum " (parameter "format"))
      (paramdef "GLenum " (parameter "type"))
      (paramdef "const GLvoid * " (parameter "data"))))
  '(*fragment*
     (heading
       "specify a one-dimensional texture image")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "target")))
                   (para "
Specifies the target texture.
                    Must be "
                         (code "GL_TEXTURE_1D")
                         " or "
                         (code "GL_PROXY_TEXTURE_1D")
                         ". "))
            (entry (% (heading (var "level")))
                   (para "
Specifies the level-of-detail number.
                    Level 0 is the base image level.
                    Level "
                         (var "n")
                         " is the "
                         (var "n")
                         "th mipmap reduction image. "))
            (entry (% (heading (var "internalFormat")))
                   (para "
Specifies the number of color components in the texture.
                    Must be 1, 2, 3, or 4, or one of the following symbolic constants: "
                         (code "GL_ALPHA")
                         ", "
                         (code "GL_ALPHA4")
                         ", "
                         (code "GL_ALPHA8")
                         ", "
                         (code "GL_ALPHA12")
                         ", "
                         (code "GL_ALPHA16")
                         ", "
                         (code "GL_COMPRESSED_ALPHA")
                         ", "
                         (code "GL_COMPRESSED_LUMINANCE")
                         ", "
                         (code "GL_COMPRESSED_LUMINANCE_ALPHA")
                         ", "
                         (code "GL_COMPRESSED_INTENSITY")
                         ", "
                         (code "GL_COMPRESSED_RGB")
                         ", "
                         (code "GL_COMPRESSED_RGBA")
                         ", "
                         (code "GL_DEPTH_COMPONENT")
                         ", "
                         (code "GL_DEPTH_COMPONENT16")
                         ", "
                         (code "GL_DEPTH_COMPONENT24")
                         ", "
                         (code "GL_DEPTH_COMPONENT32")
                         ", "
                         (code "GL_LUMINANCE")
                         ", "
                         (code "GL_LUMINANCE4")
                         ", "
                         (code "GL_LUMINANCE8")
                         ", "
                         (code "GL_LUMINANCE12")
                         ", "
                         (code "GL_LUMINANCE16")
                         ", "
                         (code "GL_LUMINANCE_ALPHA")
                         ", "
                         (code "GL_LUMINANCE4_ALPHA4")
                         ", "
                         (code "GL_LUMINANCE6_ALPHA2")
                         ", "
                         (code "GL_LUMINANCE8_ALPHA8")
                         ", "
                         (code "GL_LUMINANCE12_ALPHA4")
                         ", "
                         (code "GL_LUMINANCE12_ALPHA12")
                         ", "
                         (code "GL_LUMINANCE16_ALPHA16")
                         ", "
                         (code "GL_INTENSITY")
                         ", "
                         (code "GL_INTENSITY4")
                         ", "
                         (code "GL_INTENSITY8")
                         ", "
                         (code "GL_INTENSITY12")
                         ", "
                         (code "GL_INTENSITY16")
                         ", "
                         (code "GL_R3_G3_B2")
                         ", "
                         (code "GL_RGB")
                         ", "
                         (code "GL_RGB4")
                         ", "
                         (code "GL_RGB5")
                         ", "
                         (code "GL_RGB8")
                         ", "
                         (code "GL_RGB10")
                         ", "
                         (code "GL_RGB12")
                         ", "
                         (code "GL_RGB16")
                         ", "
                         (code "GL_RGBA")
                         ", "
                         (code "GL_RGBA2")
                         ", "
                         (code "GL_RGBA4")
                         ", "
                         (code "GL_RGB5_A1")
                         ", "
                         (code "GL_RGBA8")
                         ", "
                         (code "GL_RGB10_A2")
                         ", "
                         (code "GL_RGBA12")
                         ", "
                         (code "GL_RGBA16")
                         ", "
                         (code "GL_SLUMINANCE")
                         ", "
                         (code "GL_SLUMINANCE8")
                         ", "
                         (code "GL_SLUMINANCE_ALPHA")
                         ", "
                         (code "GL_SLUMINANCE8_ALPHA8")
                         ", "
                         (code "GL_SRGB")
                         ", "
                         (code "GL_SRGB8")
                         ", "
                         (code "GL_SRGB_ALPHA")
                         ", or "
                         (code "GL_SRGB8_ALPHA8")
                         ". "))
            (entry (% (heading (var "width")))
                   (para "
Specifies the width of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be "
                         (math "2"
                               "^"
                               (var "n")
                               "+"
                               "2"
                               "\u2061"
                               "("
                               (var "border")
                               ","
                               ")")
                         "
for some integer "
                         (math (var "n"))
                         ".
                    All
                    implementations support texture images that are at least 64 texels
                    wide. The height of the 1D texture image is 1. "))
            (entry (% (heading (var "border")))
                   (para "
Specifies the width of the border.
                    Must be either 0 or 1. "))
            (entry (% (heading (var "format")))
                   (para "
Specifies the format of the pixel data.
                    The following symbolic values are accepted: "
                         (code "GL_COLOR_INDEX")
                         ", "
                         (code "GL_RED")
                         ", "
                         (code "GL_GREEN")
                         ", "
                         (code "GL_BLUE")
                         ", "
                         (code "GL_ALPHA")
                         ", "
                         (code "GL_RGB")
                         ", "
                         (code "GL_BGR")
                         ", "
                         (code "GL_RGBA")
                         ", "
                         (code "GL_BGRA")
                         ", "
                         (code "GL_LUMINANCE")
                         ", and "
                         (code "GL_LUMINANCE_ALPHA")
                         ". "))
            (entry (% (heading (var "type")))
                   (para "
Specifies the data type of the pixel data.
                    The following symbolic values are accepted: "
                         (code "GL_UNSIGNED_BYTE")
                         ", "
                         (code "GL_BYTE")
                         ", "
                         (code "GL_BITMAP")
                         ", "
                         (code "GL_UNSIGNED_SHORT")
                         ", "
                         (code "GL_SHORT")
                         ", "
                         (code "GL_UNSIGNED_INT")
                         ", "
                         (code "GL_INT")
                         ", "
                         (code "GL_FLOAT")
                         ", "
                         (code "GL_UNSIGNED_BYTE_3_3_2")
                         ", "
                         (code "GL_UNSIGNED_BYTE_2_3_3_REV")
                         ", "
                         (code "GL_UNSIGNED_SHORT_5_6_5")
                         ", "
                         (code "GL_UNSIGNED_SHORT_5_6_5_REV")
                         ", "
                         (code "GL_UNSIGNED_SHORT_4_4_4_4")
                         ", "
                         (code "GL_UNSIGNED_SHORT_4_4_4_4_REV")
                         ", "
                         (code "GL_UNSIGNED_SHORT_5_5_5_1")
                         ", "
                         (code "GL_UNSIGNED_SHORT_1_5_5_5_REV")
                         ", "
                         (code "GL_UNSIGNED_INT_8_8_8_8")
                         ", "
                         (code "GL_UNSIGNED_INT_8_8_8_8_REV")
                         ", "
                         (code "GL_UNSIGNED_INT_10_10_10_2")
                         ", and "
                         (code "GL_UNSIGNED_INT_2_10_10_10_REV")
                         ". "))
            (entry (% (heading (var "data")))
                   (para "
Specifies a pointer to the image data in memory. ")))
     (heading "Description")
     (para "
Texturing maps a portion of a specified texture image
            onto each graphical primitive for which texturing is enabled.
            To enable and disable one-dimensional texturing, call "
           (code "glEnable")
           "
and "
           (code "glDisable")
           " with argument "
           (code "GL_TEXTURE_1D")
           ". ")
     (para "
Texture images are defined with "
           (code "glTexImage1D")
           ".
            The arguments describe the parameters of the texture image,
            such as width,
            width of the border,
            level-of-detail number
            (see "
           (code "glTexParameter")
           "),
            and the internal resolution and format used to store the image.
            The last three arguments describe how the image is represented in
            memory; they are identical to the pixel formats used for "
           (code "glDrawPixels")
           ". ")
     (para "
If "
           (var "target")
           " is "
           (code "GL_PROXY_TEXTURE_1D")
           ", no data is read from "
           (var "data")
           ", but
            all of the texture image state is recalculated, checked for
            consistency, and checked against the implementation's capabilities.
            If the implementation cannot handle a texture of the
            requested texture size, it sets all of the image state to 0,
            but does not generate an error (see "
           (code "glGetError")
           "). To query for an
            entire mipmap array, use an image array level greater than or equal to
            1. ")
     (para "
If "
           (var "target")
           " is "
           (code "GL_TEXTURE_1D")
           ",
            data is read from "
           (var "data")
           " as a sequence of signed or unsigned bytes,
            shorts,
            or longs,
            or single-precision floating-point values,
            depending on "
           (var "type")
           ".
            These values are grouped into sets of one,
            two,
            three,
            or four values,
            depending on "
           (var "format")
           ",
            to form elements.
            If "
           (var "type")
           " is "
           (code "GL_BITMAP")
           ",
            the data is considered as a string of unsigned bytes
            (and "
           (var "format")
           " must be "
           (code "GL_COLOR_INDEX")
           ").
            Each data byte is treated as eight 1-bit elements,
            with bit ordering determined by "
           (code "GL_UNPACK_LSB_FIRST")
           "
(see "
           (code "glPixelStore")
           "). ")
     (para "
If a non-zero named buffer object is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target 
            (see "
           (code "glBindBuffer")
           ") while a texture image is
            specified, "
           (var "data")
           " is treated as a byte offset into the buffer object's data store. ")
     (para "
The first element corresponds to the left end of the texture array.
            Subsequent elements progress left-to-right through the remaining texels
            in the texture array.
            The final element corresponds to the right end of the texture array. ")
     (para (var "format")
           " determines the composition of each element in "
           (var "data")
           ".
            It can assume one of these symbolic values: ")
     (table (% (formatter (asis)))
            (entry (% (heading (code "GL_COLOR_INDEX")))
                   (para "
Each element is a single value,
                        a color index.
                        The GL converts it to fixed point
                        (with an unspecified number of zero bits to the right of the binary point),
                        shifted left or right depending on the value and sign of "
                         (code "GL_INDEX_SHIFT")
                         ",
                        and added to "
                         (code "GL_INDEX_OFFSET")
                         "
(see "
                         (code "glPixelTransfer")
                         ").
                        The resulting index is converted to a set of color components
                        using the "
                         (code "GL_PIXEL_MAP_I_TO_R")
                         ", "
                         (code "GL_PIXEL_MAP_I_TO_G")
                         ", "
                         (code "GL_PIXEL_MAP_I_TO_B")
                         ", and "
                         (code "GL_PIXEL_MAP_I_TO_A")
                         " tables,
                        and clamped to the range [0,1]. "))
            (entry (% (heading (code "GL_RED")))
                   (para "
Each element is a single red component.
                        The GL converts it to floating point and assembles it into an RGBA element
                        by attaching 0 for green and blue, and 1 for alpha.
                        Each component is then multiplied by the signed scale factor "
                         (code "GL_c_SCALE")
                         ",
                        added to the signed bias "
                         (code "GL_c_BIAS")
                         ",
                        and clamped to the range [0,1]
                        (see "
                         (code "glPixelTransfer")
                         "). "))
            (entry (% (heading (code "GL_GREEN")))
                   (para "
Each element is a single green component.
                        The GL converts it to floating point and assembles it into an RGBA element
                        by attaching 0 for red and blue, and 1 for alpha.
                        Each component is then multiplied by the signed scale factor "
                         (code "GL_c_SCALE")
                         ",
                        added to the signed bias "
                         (code "GL_c_BIAS")
                         ",
                        and clamped to the range [0,1]
                        (see "
                         (code "glPixelTransfer")
                         "). "))
            (entry (% (heading (code "GL_BLUE")))
                   (para "
Each element is a single blue component.
                        The GL converts it to floating point and assembles it into an RGBA element
                        by attaching 0 for red and green, and 1 for alpha.
                        Each component is then multiplied by the signed scale factor "
                         (code "GL_c_SCALE")
                         ",
                        added to the signed bias "
                         (code "GL_c_BIAS")
                         ",
                        and clamped to the range [0,1]
                        (see "
                         (code "glPixelTransfer")
                         "). "))
            (entry (% (heading (code "GL_ALPHA")))
                   (para "
Each element is a single alpha component.
                        The GL converts it to floating point and assembles it into an RGBA element
                        by attaching 0 for red, green, and blue.
                        Each component is then multiplied by the signed scale factor "
                         (code "GL_c_SCALE")
                         ",
                        added to the signed bias "
                         (code "GL_c_BIAS")
                         ",
                        and clamped to the range [0,1]
                        (see "
                         (code "glPixelTransfer")
                         "). "))
            (entry (% (heading (code "GL_INTENSITY")))
                   (para "
Each element is a single intensity value.
                        The GL converts it to floating point,
                        then assembles it into an RGBA element by replicating the intensity value
                        three times for red, green, blue, and alpha.
                        Each component is then multiplied by the signed scale factor "
                         (code "GL_c_SCALE")
                         ",
                        added to the signed bias "
                         (code "GL_c_BIAS")
                         ",
                        and clamped to the range [0,1]
                        (see "
                         (code "glPixelTransfer")
                         "). "))
            (entry (% (heading (code "GL_RGB"))))
            (entry (% (heading (code "GL_BGR")))
                   (para "
Each element is an RGB triple.
                        The GL converts it to floating point and assembles it into an RGBA element
                        by attaching 1 for alpha.
                        Each component is then multiplied by the signed scale factor "
                         (code "GL_c_SCALE")
                         ",
                        added to the signed bias "
                         (code "GL_c_BIAS")
                         ",
                        and clamped to the range [0,1]
                        (see "
                         (code "glPixelTransfer")
                         "). "))
            (entry (% (heading (code "GL_RGBA"))))
            (entry (% (heading (code "GL_BGRA")))
                   (para "
Each element contains all four components.
                        Each component is multiplied by the signed scale factor "
                         (code "GL_c_SCALE")
                         ",
                        added to the signed bias "
                         (code "GL_c_BIAS")
                         ",
                        and clamped to the range [0,1]
                        (see "
                         (code "glPixelTransfer")
                         "). "))
            (entry (% (heading (code "GL_LUMINANCE")))
                   (para "
Each element is a single luminance value.
                        The GL converts it to floating point,
                        then assembles it into an RGBA element by replicating the luminance value
                        three times for red, green, and blue and attaching 1 for alpha.
                        Each component is then multiplied by the signed scale factor "
                         (code "GL_c_SCALE")
                         ",
                        added to the signed bias "
                         (code "GL_c_BIAS")
                         ",
                        and clamped to the range [0,1]
                        (see "
                         (code "glPixelTransfer")
                         "). "))
            (entry (% (heading (code "GL_LUMINANCE_ALPHA")))
                   (para "
Each element is a luminance/alpha pair.
                        The GL converts it to floating point,
                        then assembles it into an RGBA element by replicating the luminance value
                        three times for red, green, and blue.
                        Each component is then multiplied by the signed scale factor "
                         (code "GL_c_SCALE")
                         ",
                        added to the signed bias "
                         (code "GL_c_BIAS")
                         ",
                        and clamped to the range [0,1] (see "
                         (code "glPixelTransfer")
                         "). "))
            (entry (% (heading (code "GL_DEPTH_COMPONENT")))
                   (para "
Each element is a single depth value.
                        The GL converts it to floating point, multiplies by the signed scale factor "
                         (code "GL_DEPTH_SCALE")
                         ", adds the signed bias "
                         (code "GL_DEPTH_BIAS")
                         ",
                        and clamps to the range [0,1] (see "
                         (code "glPixelTransfer")
                         "). ")))
     (para "
Refer to the "
           (code "glDrawPixels")
           " reference page for a description of
            the acceptable values for the "
           (var "type")
           " parameter. ")
     (para "
If an application wants to store the texture at a certain
            resolution or in a certain format, it can request the resolution
            and format with "
           (var "internalFormat")
           ". The GL will choose an internal
            representation that closely approximates that requested by "
           (var "internalFormat")
           ", but
            it may not match exactly.
            (The representations specified by "
           (code "GL_LUMINANCE")
           ", "
           (code "GL_LUMINANCE_ALPHA")
           ", "
           (code "GL_RGB")
           ",
            and "
           (code "GL_RGBA")
           " must match exactly. The numeric values 1, 2, 3, and 4
            may also be used to specify the above representations.) ")
     (para "
If the "
           (var "internalFormat")
           " parameter is one of the generic compressed formats,\t"
           (code "GL_COMPRESSED_ALPHA")
           ",\t"
           (code "GL_COMPRESSED_INTENSITY")
           ",\t"
           (code "GL_COMPRESSED_LUMINANCE")
           ",\t"
           (code "GL_COMPRESSED_LUMINANCE_ALPHA")
           ",\t"
           (code "GL_COMPRESSED_RGB")
           ", or\t"
           (code "GL_COMPRESSED_RGBA")
           ", the GL will replace the internal format with the symbolic constant for a specific internal format and compress the texture before storage.  If no corresponding internal format is available, or the GL can not compress that image for any reason, the internal format is instead replaced with a corresponding base internal format. ")
     (para "
If the "
           (var "internalFormat")
           " parameter is "
           (code "GL_SRGB")
           ",\t"
           (code "GL_SRGB8")
           ",\t"
           (code "GL_SRGB_ALPHA")
           ",\t"
           (code "GL_SRGB8_ALPHA8")
           ",\t"
           (code "GL_SLUMINANCE")
           ",\t"
           (code "GL_SLUMINANCE8")
           ",\t"
           (code "GL_SLUMINANCE_ALPHA")
           ", or\t"
           (code "GL_SLUMINANCE8_ALPHA8")
           ", the texture is treated as if the red, green, blue, or luminance components are encoded in the sRGB color space.    Any alpha component is left unchanged.  The conversion from the sRGB encoded component\t"
           (math (var "c") "_" (var "s"))
           "
to a linear component\t"
           (math (var "c") "_" (var "l"))
           "
is:\t")
     (para (math (var "c")
                 "_"
                 (var "l")
                 "="
                 "{"
                 "("
                 (var "c")
                 "_"
                 (var "s")
                 "/"
                 "12.92"
                 " "
                 " "
                 "if"
                 " "
                 (var "c")
                 "_"
                 (var "s")
                 "≤"
                 "0.04045"
                 ")"
                 ", "
                 "("
                 "("
                 (code "c")
                 "_"
                 (code "s")
                 "+"
                 "0.055"
                 "/"
                 "1.055"
                 ")"
                 "^"
                 "2.4"
                 " "
                 " "
                 "if"
                 " "
                 (var "c")
                 "_"
                 (var "s")
                 ">"
                 "0.04045"
                 ")"))
     (para "
Assume\t"
           (math (var "c") "_" (var "s"))
           "
is the sRGB component in the range [0,1]. ")
     (para "
Use the "
           (code "GL_PROXY_TEXTURE_1D")
           " target to try out a resolution and
            format. The implementation will
            update and recompute its best match for the requested storage resolution
            and format. To then query this state, call "
           (code "glGetTexLevelParameter")
           ".
            If the texture cannot be accommodated, texture state is set to 0. ")
     (para "
A one-component texture image uses only the red component of the RGBA
            color from "
           (var "data")
           ".
            A two-component image uses the R and A values.
            A three-component image uses the R, G, and B values.
            A four-component image uses all of the RGBA components. ")
     (para "
Depth textures can be treated as LUMINANCE, INTENSITY or ALPHA textures during texture filtering and application.\xa0Image-based shadowing\xa0can\xa0be\xa0enabled\xa0by\xa0comparing texture r coordinates to depth texture values to generate a boolean result.  See "
           (code "glTexParameter")
           " for details on texture comparison. ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "target")
           " is not "
           (code "GL_TEXTURE_1D")
           "
or "
           (code "GL_PROXY_TEXTURE_1D")
           ". ")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "format")
           " is not an accepted
            format constant.  Format constants other than "
           (code "GL_STENCIL_INDEX")
           "
are accepted. ")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "type")
           " is not a type constant. ")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "type")
           " is "
           (code "GL_BITMAP")
           " and "
           (var "format")
           " is not "
           (code "GL_COLOR_INDEX")
           ". ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "level")
           " is less than 0. ")
     (para (code "GL_INVALID_VALUE")
           " may be generated if "
           (var "level")
           " is greater than "
           (math (var "log")
                 "_"
                 "2"
                 "\u2061"
                 "("
                 (var "max")
                 ","
                 ")")
           ",
            where "
           (var "max")
           " is the returned value of "
           (code "GL_MAX_TEXTURE_SIZE")
           ". ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "internalFormat")
           " is not 1, 2, 3, 4, or
            one of the accepted resolution and format symbolic constants. ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "width")
           " is less than 0
            or greater than 2 + "
           (code "GL_MAX_TEXTURE_SIZE")
           ". ")
     (para (code "GL_INVALID_VALUE")
           " is generated if non-power-of-two textures are not supported and the "
           (var "width")
           " cannot be represented as\t"
           (math "2"
                 "^"
                 (var "n")
                 "+"
                 "2"
                 "\u2061"
                 "("
                 (var "border")
                 ","
                 ")")
           "
for some integer value of "
           (var "n")
           ". ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "border")
           " is not 0 or 1. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (var "type")
           " is one of "
           (code "GL_UNSIGNED_BYTE_3_3_2")
           ", "
           (code "GL_UNSIGNED_BYTE_2_3_3_REV")
           ", "
           (code "GL_UNSIGNED_SHORT_5_6_5")
           ", or "
           (code "GL_UNSIGNED_SHORT_5_6_5_REV")
           "
and "
           (var "format")
           " is not "
           (code "GL_RGB")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (var "type")
           " is one of "
           (code "GL_UNSIGNED_SHORT_4_4_4_4")
           ", "
           (code "GL_UNSIGNED_SHORT_4_4_4_4_REV")
           ", "
           (code "GL_UNSIGNED_SHORT_5_5_5_1")
           ", "
           (code "GL_UNSIGNED_SHORT_1_5_5_5_REV")
           ", "
           (code "GL_UNSIGNED_INT_8_8_8_8")
           ", "
           (code "GL_UNSIGNED_INT_8_8_8_8_REV")
           ", "
           (code "GL_UNSIGNED_INT_10_10_10_2")
           ", or "
           (code "GL_UNSIGNED_INT_2_10_10_10_REV")
           "
and "
           (var "format")
           " is neither "
           (code "GL_RGBA")
           " nor "
           (code "GL_BGRA")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (var "format")
           " is "
           (code "GL_DEPTH_COMPONENT")
           " and "
           (var "internalFormat")
           " is not "
           (code "GL_DEPTH_COMPONENT")
           ", "
           (code "GL_DEPTH_COMPONENT16")
           ", "
           (code "GL_DEPTH_COMPONENT24")
           ", or "
           (code "GL_DEPTH_COMPONENT32")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (var "internalFormat")
           " is "
           (code "GL_DEPTH_COMPONENT")
           ", "
           (code "GL_DEPTH_COMPONENT16")
           ", "
           (code "GL_DEPTH_COMPONENT24")
           ", or "
           (code "GL_DEPTH_COMPONENT32")
           ", and "
           (var "format")
           " is
            not "
           (code "GL_DEPTH_COMPONENT")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target and the buffer object's data store is currently mapped. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target and the data would be unpacked from the buffer 
            object such that the memory reads required would exceed the data store size. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target and "
           (var "data")
           " is not evenly divisible 
            into the number of bytes needed to store in memory a datum indicated by "
           (var "type")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glTexImage1D")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glTexImage2D
  "glTexImage2D"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glTexImage2D"))
      (paramdef "GLenum " (parameter "target"))
      (paramdef "GLint " (parameter "level"))
      (paramdef "GLint " (parameter "internalFormat"))
      (paramdef "GLsizei " (parameter "width"))
      (paramdef "GLsizei " (parameter "height"))
      (paramdef "GLint " (parameter "border"))
      (paramdef "GLenum " (parameter "format"))
      (paramdef "GLenum " (parameter "type"))
      (paramdef "const GLvoid * " (parameter "data"))))
  '(*fragment*
     (heading
       "specify a two-dimensional texture image")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "target")))
                   (para "
Specifies the target texture.
                    Must be "
                         (code "GL_TEXTURE_2D")
                         ", "
                         (code "GL_PROXY_TEXTURE_2D")
                         ", "
                         (code "GL_TEXTURE_CUBE_MAP_POSITIVE_X")
                         ", "
                         (code "GL_TEXTURE_CUBE_MAP_NEGATIVE_X")
                         ", "
                         (code "GL_TEXTURE_CUBE_MAP_POSITIVE_Y")
                         ", "
                         (code "GL_TEXTURE_CUBE_MAP_NEGATIVE_Y")
                         ", "
                         (code "GL_TEXTURE_CUBE_MAP_POSITIVE_Z")
                         ", "
                         (code "GL_TEXTURE_CUBE_MAP_NEGATIVE_Z")
                         ", or "
                         (code "GL_PROXY_TEXTURE_CUBE_MAP")
                         ". "))
            (entry (% (heading (var "level")))
                   (para "
Specifies the level-of-detail number.
                    Level 0 is the base image level.
                    Level "
                         (var "n")
                         " is the "
                         (var "n")
                         "th mipmap reduction image. "))
            (entry (% (heading (var "internalFormat")))
                   (para "
Specifies the number of color components in the texture.
                    Must be 1, 2, 3, or 4, or one of the following symbolic constants: "
                         (code "GL_ALPHA")
                         ", "
                         (code "GL_ALPHA4")
                         ", "
                         (code "GL_ALPHA8")
                         ", "
                         (code "GL_ALPHA12")
                         ", "
                         (code "GL_ALPHA16")
                         ", "
                         (code "GL_COMPRESSED_ALPHA")
                         ", "
                         (code "GL_COMPRESSED_LUMINANCE")
                         ", "
                         (code "GL_COMPRESSED_LUMINANCE_ALPHA")
                         ", "
                         (code "GL_COMPRESSED_INTENSITY")
                         ", "
                         (code "GL_COMPRESSED_RGB")
                         ", "
                         (code "GL_COMPRESSED_RGBA")
                         ", "
                         (code "GL_DEPTH_COMPONENT")
                         ", "
                         (code "GL_DEPTH_COMPONENT16")
                         ", "
                         (code "GL_DEPTH_COMPONENT24")
                         ", "
                         (code "GL_DEPTH_COMPONENT32")
                         ", "
                         (code "GL_LUMINANCE")
                         ", "
                         (code "GL_LUMINANCE4")
                         ", "
                         (code "GL_LUMINANCE8")
                         ", "
                         (code "GL_LUMINANCE12")
                         ", "
                         (code "GL_LUMINANCE16")
                         ", "
                         (code "GL_LUMINANCE_ALPHA")
                         ", "
                         (code "GL_LUMINANCE4_ALPHA4")
                         ", "
                         (code "GL_LUMINANCE6_ALPHA2")
                         ", "
                         (code "GL_LUMINANCE8_ALPHA8")
                         ", "
                         (code "GL_LUMINANCE12_ALPHA4")
                         ", "
                         (code "GL_LUMINANCE12_ALPHA12")
                         ", "
                         (code "GL_LUMINANCE16_ALPHA16")
                         ", "
                         (code "GL_INTENSITY")
                         ", "
                         (code "GL_INTENSITY4")
                         ", "
                         (code "GL_INTENSITY8")
                         ", "
                         (code "GL_INTENSITY12")
                         ", "
                         (code "GL_INTENSITY16")
                         ", "
                         (code "GL_R3_G3_B2")
                         ", "
                         (code "GL_RGB")
                         ", "
                         (code "GL_RGB4")
                         ", "
                         (code "GL_RGB5")
                         ", "
                         (code "GL_RGB8")
                         ", "
                         (code "GL_RGB10")
                         ", "
                         (code "GL_RGB12")
                         ", "
                         (code "GL_RGB16")
                         ", "
                         (code "GL_RGBA")
                         ", "
                         (code "GL_RGBA2")
                         ", "
                         (code "GL_RGBA4")
                         ", "
                         (code "GL_RGB5_A1")
                         ", "
                         (code "GL_RGBA8")
                         ", "
                         (code "GL_RGB10_A2")
                         ", "
                         (code "GL_RGBA12")
                         ", "
                         (code "GL_RGBA16")
                         ", "
                         (code "GL_SLUMINANCE")
                         ", "
                         (code "GL_SLUMINANCE8")
                         ", "
                         (code "GL_SLUMINANCE_ALPHA")
                         ", "
                         (code "GL_SLUMINANCE8_ALPHA8")
                         ", "
                         (code "GL_SRGB")
                         ", "
                         (code "GL_SRGB8")
                         ", "
                         (code "GL_SRGB_ALPHA")
                         ", or "
                         (code "GL_SRGB8_ALPHA8")
                         ". "))
            (entry (% (heading (var "width")))
                   (para "
Specifies the width of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be "
                         (math "2"
                               "^"
                               (var "n")
                               "+"
                               "2"
                               "\u2061"
                               "("
                               (var "border")
                               ","
                               ")")
                         "
for some integer "
                         (math (var "n"))
                         ".
                    All
                    implementations support texture images that are at least 64 texels
                    wide. "))
            (entry (% (heading (var "height")))
                   (para "
Specifies the height of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be "
                         (math "2"
                               "^"
                               (var "m")
                               "+"
                               "2"
                               "\u2061"
                               "("
                               (var "border")
                               ","
                               ")")
                         "
for some integer "
                         (math (var "m"))
                         ".
                    All
                    implementations support texture images that are at least 64 texels
                    high. "))
            (entry (% (heading (var "border")))
                   (para "
Specifies the width of the border.
                    Must be either 0 or 1. "))
            (entry (% (heading (var "format")))
                   (para "
Specifies the format of the pixel data.
                    The following symbolic values are accepted: "
                         (code "GL_COLOR_INDEX")
                         ", "
                         (code "GL_RED")
                         ", "
                         (code "GL_GREEN")
                         ", "
                         (code "GL_BLUE")
                         ", "
                         (code "GL_ALPHA")
                         ", "
                         (code "GL_RGB")
                         ", "
                         (code "GL_BGR")
                         ", "
                         (code "GL_RGBA")
                         ", "
                         (code "GL_BGRA")
                         ", "
                         (code "GL_LUMINANCE")
                         ", and "
                         (code "GL_LUMINANCE_ALPHA")
                         ". "))
            (entry (% (heading (var "type")))
                   (para "
Specifies the data type of the pixel data.
                    The following symbolic values are accepted: "
                         (code "GL_UNSIGNED_BYTE")
                         ", "
                         (code "GL_BYTE")
                         ", "
                         (code "GL_BITMAP")
                         ", "
                         (code "GL_UNSIGNED_SHORT")
                         ", "
                         (code "GL_SHORT")
                         ", "
                         (code "GL_UNSIGNED_INT")
                         ", "
                         (code "GL_INT")
                         ", "
                         (code "GL_FLOAT")
                         ", "
                         (code "GL_UNSIGNED_BYTE_3_3_2")
                         ", "
                         (code "GL_UNSIGNED_BYTE_2_3_3_REV")
                         ", "
                         (code "GL_UNSIGNED_SHORT_5_6_5")
                         ", "
                         (code "GL_UNSIGNED_SHORT_5_6_5_REV")
                         ", "
                         (code "GL_UNSIGNED_SHORT_4_4_4_4")
                         ", "
                         (code "GL_UNSIGNED_SHORT_4_4_4_4_REV")
                         ", "
                         (code "GL_UNSIGNED_SHORT_5_5_5_1")
                         ", "
                         (code "GL_UNSIGNED_SHORT_1_5_5_5_REV")
                         ", "
                         (code "GL_UNSIGNED_INT_8_8_8_8")
                         ", "
                         (code "GL_UNSIGNED_INT_8_8_8_8_REV")
                         ", "
                         (code "GL_UNSIGNED_INT_10_10_10_2")
                         ", and "
                         (code "GL_UNSIGNED_INT_2_10_10_10_REV")
                         ". "))
            (entry (% (heading (var "data")))
                   (para "
Specifies a pointer to the image data in memory. ")))
     (heading "Description")
     (para "
Texturing maps a portion of a specified texture image onto each graphical primitive for which texturing is enabled.  To enable and disable two-dimensional texturing, call "
           (code "glEnable")
           " and "
           (code "glDisable")
           " with argument "
           (code "GL_TEXTURE_2D")
           ".  To enable and disable texturing using cube-mapped texture, call "
           (code "glEnable")
           " and "
           (code "glDisable")
           " with argument "
           (code "GL_TEXTURE_CUBE_MAP")
           ". ")
     (para "
To define texture images, call "
           (code "glTexImage2D")
           ".
            The arguments describe the parameters of the texture image,
            such as height,
            width,
            width of the border,
            level-of-detail number
            (see "
           (code "glTexParameter")
           "),
            and number of color components provided.
            The last three arguments describe how the image is represented in memory;
            they are identical to the pixel formats used for "
           (code "glDrawPixels")
           ". ")
     (para "
If "
           (var "target")
           " is "
           (code "GL_PROXY_TEXTURE_2D")
           " or "
           (code "GL_PROXY_TEXTURE_CUBE_MAP")
           ", no data is read from "
           (var "data")
           ", but
            all of the texture image state is recalculated, checked for
            consistency, and checked
            against the implementation's capabilities. If the implementation cannot
            handle a texture of the requested texture size, it sets
            all of the image state to 0,
            but does not generate an error (see "
           (code "glGetError")
           "). To query for an
            entire mipmap array, use an image array level greater than or equal to
            1. ")
     (para "
If "
           (var "target")
           " is "
           (code "GL_TEXTURE_2D")
           ", or one of the "
           (code "GL_TEXTURE_CUBE_MAP")
           "
targets, data is read from "
           (var "data")
           " as a sequence of signed or unsigned
            bytes, shorts, or longs, or single-precision floating-point values,
            depending on "
           (var "type")
           ".  These values are grouped into sets of one, two,
            three, or four values, depending on "
           (var "format")
           ", to form elements.  If "
           (var "type")
           "
is "
           (code "GL_BITMAP")
           ", the data is considered as a string of unsigned bytes
            (and "
           (var "format")
           " must be "
           (code "GL_COLOR_INDEX")
           ").
            Each data byte is treated as eight 1-bit elements,
            with bit ordering determined by "
           (code "GL_UNPACK_LSB_FIRST")
           "
(see "
           (code "glPixelStore")
           "). ")
     (para "
If a non-zero named buffer object is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target 
            (see "
           (code "glBindBuffer")
           ") while a texture image is
            specified, "
           (var "data")
           " is treated as a byte offset into the buffer object's data store. ")
     (para "
The first element corresponds to the lower left corner of the texture
            image.
            Subsequent elements progress left-to-right through the remaining texels
            in the lowest row of the texture image, and then in successively higher
            rows of the texture image.
            The final element corresponds to the upper right corner of the texture
            image. ")
     (para (var "format")
           " determines the composition of each element in "
           (var "data")
           ".
            It can assume one of these symbolic values: ")
     (table (% (formatter (asis)))
            (entry (% (heading (code "GL_COLOR_INDEX")))
                   (para "
Each element is a single value,
                        a color index.
                        The GL converts it to fixed point
                        (with an unspecified number of zero bits to the right of the binary point),
                        shifted left or right depending on the value and sign of "
                         (code "GL_INDEX_SHIFT")
                         ",
                        and added to "
                         (code "GL_INDEX_OFFSET")
                         "
(see "
                         (code "glPixelTransfer")
                         ").
                        The resulting index is converted to a set of color components
                        using the "
                         (code "GL_PIXEL_MAP_I_TO_R")
                         ", "
                         (code "GL_PIXEL_MAP_I_TO_G")
                         ", "
                         (code "GL_PIXEL_MAP_I_TO_B")
                         ", and "
                         (code "GL_PIXEL_MAP_I_TO_A")
                         " tables,
                        and clamped to the range [0,1]. "))
            (entry (% (heading (code "GL_RED")))
                   (para "
Each element is a single red component.
                        The GL converts it to floating point and assembles it into an RGBA element
                        by attaching 0 for green and blue, and 1 for alpha.
                        Each component is then multiplied by the signed scale factor "
                         (code "GL_c_SCALE")
                         ",
                        added to the signed bias "
                         (code "GL_c_BIAS")
                         ",
                        and clamped to the range [0,1]
                        (see "
                         (code "glPixelTransfer")
                         "). "))
            (entry (% (heading (code "GL_GREEN")))
                   (para "
Each element is a single green component.
                        The GL converts it to floating point and assembles it into an RGBA element
                        by attaching 0 for red and blue, and 1 for alpha.
                        Each component is then multiplied by the signed scale factor "
                         (code "GL_c_SCALE")
                         ",
                        added to the signed bias "
                         (code "GL_c_BIAS")
                         ",
                        and clamped to the range [0,1]
                        (see "
                         (code "glPixelTransfer")
                         "). "))
            (entry (% (heading (code "GL_BLUE")))
                   (para "
Each element is a single blue component.
                        The GL converts it to floating point and assembles it into an RGBA element
                        by attaching 0 for red and green, and 1 for alpha.
                        Each component is then multiplied by the signed scale factor "
                         (code "GL_c_SCALE")
                         ",
                        added to the signed bias "
                         (code "GL_c_BIAS")
                         ",
                        and clamped to the range [0,1]
                        (see "
                         (code "glPixelTransfer")
                         "). "))
            (entry (% (heading (code "GL_ALPHA")))
                   (para "
Each element is a single alpha component.
                        The GL converts it to floating point and assembles it into an RGBA element
                        by attaching 0 for red, green, and blue.
                        Each component is then multiplied by the signed scale factor "
                         (code "GL_c_SCALE")
                         ",
                        added to the signed bias "
                         (code "GL_c_BIAS")
                         ",
                        and clamped to the range [0,1]
                        (see "
                         (code "glPixelTransfer")
                         "). "))
            (entry (% (heading (code "GL_INTENSITY")))
                   (para "
Each element is a single intensity value.
                        The GL converts it to floating point,
                        then assembles it into an RGBA element by replicating the intensity value
                        three times for red, green, blue, and alpha.
                        Each component is then multiplied by the signed scale factor "
                         (code "GL_c_SCALE")
                         ",
                        added to the signed bias "
                         (code "GL_c_BIAS")
                         ",
                        and clamped to the range [0,1]
                        (see "
                         (code "glPixelTransfer")
                         "). "))
            (entry (% (heading (code "GL_RGB"))))
            (entry (% (heading (code "GL_BGR")))
                   (para "
Each element is an RGB triple.
                        The GL converts it to floating point and assembles it into an RGBA element
                        by attaching 1 for alpha.
                        Each component is then multiplied by the signed scale factor "
                         (code "GL_c_SCALE")
                         ",
                        added to the signed bias "
                         (code "GL_c_BIAS")
                         ",
                        and clamped to the range [0,1]
                        (see "
                         (code "glPixelTransfer")
                         "). "))
            (entry (% (heading (code "GL_RGBA"))))
            (entry (% (heading (code "GL_BGRA")))
                   (para "
Each element contains all four components.
                        Each component is multiplied by the signed scale factor "
                         (code "GL_c_SCALE")
                         ",
                        added to the signed bias "
                         (code "GL_c_BIAS")
                         ",
                        and clamped to the range [0,1]
                        (see "
                         (code "glPixelTransfer")
                         "). "))
            (entry (% (heading (code "GL_LUMINANCE")))
                   (para "
Each element is a single luminance value.
                        The GL converts it to floating point,
                        then assembles it into an RGBA element by replicating the luminance value
                        three times for red, green, and blue and attaching 1 for alpha.
                        Each component is then multiplied by the signed scale factor "
                         (code "GL_c_SCALE")
                         ",
                        added to the signed bias "
                         (code "GL_c_BIAS")
                         ",
                        and clamped to the range [0,1]
                        (see "
                         (code "glPixelTransfer")
                         "). "))
            (entry (% (heading (code "GL_LUMINANCE_ALPHA")))
                   (para "
Each element is a luminance/alpha pair.
                        The GL converts it to floating point,
                        then assembles it into an RGBA element by replicating the luminance value
                        three times for red, green, and blue.
                        Each component is then multiplied by the signed scale factor "
                         (code "GL_c_SCALE")
                         ",
                        added to the signed bias "
                         (code "GL_c_BIAS")
                         ",
                        and clamped to the range [0,1] (see "
                         (code "glPixelTransfer")
                         "). "))
            (entry (% (heading (code "GL_DEPTH_COMPONENT")))
                   (para "
Each element is a single depth value.
                        The GL converts it to floating point, multiplies by the signed scale factor "
                         (code "GL_DEPTH_SCALE")
                         ", adds the signed bias "
                         (code "GL_DEPTH_BIAS")
                         ",
                        and clamps to the range [0,1] (see "
                         (code "glPixelTransfer")
                         "). ")))
     (para "
Refer to the "
           (code "glDrawPixels")
           " reference page for a description of
            the acceptable values for the "
           (var "type")
           " parameter. ")
     (para "
If an application wants to store the texture at a certain
            resolution or in a certain format, it can request the resolution
            and format with "
           (var "internalFormat")
           ". The GL will choose an internal
            representation that closely approximates that requested by "
           (var "internalFormat")
           ", but
            it may not match exactly.
            (The representations specified by "
           (code "GL_LUMINANCE")
           ", "
           (code "GL_LUMINANCE_ALPHA")
           ", "
           (code "GL_RGB")
           ",
            and "
           (code "GL_RGBA")
           " must match exactly. The numeric values 1, 2, 3, and 4
            may also be used to specify the above representations.) ")
     (para "
If the "
           (var "internalFormat")
           " parameter is one of the generic compressed formats,\t"
           (code "GL_COMPRESSED_ALPHA")
           ",\t"
           (code "GL_COMPRESSED_INTENSITY")
           ",\t"
           (code "GL_COMPRESSED_LUMINANCE")
           ",\t"
           (code "GL_COMPRESSED_LUMINANCE_ALPHA")
           ",\t"
           (code "GL_COMPRESSED_RGB")
           ", or\t"
           (code "GL_COMPRESSED_RGBA")
           ", the GL will replace the internal format with the symbolic constant for a specific internal format and compress the texture before storage.  If no corresponding internal format is available, or the GL can not compress that image for any reason, the internal format is instead replaced with a corresponding base internal format. ")
     (para "
If the "
           (var "internalFormat")
           " parameter is "
           (code "GL_SRGB")
           ",\t"
           (code "GL_SRGB8")
           ",\t"
           (code "GL_SRGB_ALPHA")
           ",\t"
           (code "GL_SRGB8_ALPHA8")
           ",\t"
           (code "GL_SLUMINANCE")
           ",\t"
           (code "GL_SLUMINANCE8")
           ",\t"
           (code "GL_SLUMINANCE_ALPHA")
           ", or\t"
           (code "GL_SLUMINANCE8_ALPHA8")
           ", the texture is treated as if the red, green, blue, or luminance components are encoded in the sRGB color space.    Any alpha component is left unchanged.  The conversion from the sRGB encoded component\t"
           (math (var "c") "_" (var "s"))
           "
to a linear component\t"
           (math (var "c") "_" (var "l"))
           "
is:\t")
     (para (math (var "c")
                 "_"
                 (var "l")
                 "="
                 "{"
                 "("
                 (var "c")
                 "_"
                 (var "s")
                 "/"
                 "12.92"
                 " "
                 " "
                 "if"
                 " "
                 (var "c")
                 "_"
                 (var "s")
                 "≤"
                 "0.04045"
                 ")"
                 ", "
                 "("
                 "("
                 (code "c")
                 "_"
                 (code "s")
                 "+"
                 "0.055"
                 "/"
                 "1.055"
                 ")"
                 "^"
                 "2.4"
                 " "
                 " "
                 "if"
                 " "
                 (var "c")
                 "_"
                 (var "s")
                 ">"
                 "0.04045"
                 ")"))
     (para "
Assume\t"
           (math (var "c") "_" (var "s"))
           "
is the sRGB component in the range [0,1]. ")
     (para "
Use the "
           (code "GL_PROXY_TEXTURE_2D")
           " or "
           (code "GL_PROXY_TEXTURE_CUBE_MAP")
           " target to try out a resolution and
            format. The implementation will
            update and recompute its best match for the requested storage resolution
            and format. To then query this state, call "
           (code "glGetTexLevelParameter")
           ".
            If the texture cannot be accommodated, texture state is set to 0. ")
     (para "
A one-component texture image uses only the red component of the RGBA
            color extracted from "
           (var "data")
           ".
            A two-component image uses the R and A values.
            A three-component image uses the R, G, and B values.
            A four-component image uses all of the RGBA components. ")
     (para "
Depth textures can be treated as LUMINANCE, INTENSITY or ALPHA textures during texture filtering and application.\xa0Image-based shadowing\xa0can\xa0be\xa0enabled\xa0by\xa0comparing texture r coordinates to depth texture values to generate a boolean result.  See "
           (code "glTexParameter")
           " for details on texture comparison. ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "target")
           " is not "
           (code "GL_TEXTURE_2D")
           ", "
           (code "GL_PROXY_TEXTURE_2D")
           ", "
           (code "GL_PROXY_TEXTURE_CUBE_MAP")
           ",\t"
           (code "GL_TEXTURE_CUBE_MAP_POSITIVE_X")
           ",\t"
           (code "GL_TEXTURE_CUBE_MAP_NEGATIVE_X")
           ",\t"
           (code "GL_TEXTURE_CUBE_MAP_POSITIVE_Y")
           ",\t"
           (code "GL_TEXTURE_CUBE_MAP_NEGATIVE_Y")
           ",\t"
           (code "GL_TEXTURE_CUBE_MAP_POSITIVE_Z")
           ", or\t"
           (code "GL_TEXTURE_CUBE_MAP_NEGATIVE_Z")
           ". ")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "target")
           " is one of the six cube map 2D image targets and the width and height parameters are not equal. ")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "type")
           " is not a type constant. ")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "type")
           " is "
           (code "GL_BITMAP")
           " and "
           (var "format")
           " is not "
           (code "GL_COLOR_INDEX")
           ". ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "width")
           " or "
           (var "height")
           " is less than 0
            or greater than 2 + "
           (code "GL_MAX_TEXTURE_SIZE")
           ". ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "level")
           " is less than 0. ")
     (para (code "GL_INVALID_VALUE")
           " may be generated if "
           (var "level")
           " is greater than "
           (math (var "log")
                 "_"
                 "2"
                 "\u2061"
                 "("
                 (var "max")
                 ","
                 ")")
           ",
            where "
           (var "max")
           " is the returned value of "
           (code "GL_MAX_TEXTURE_SIZE")
           ". ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "internalFormat")
           " is not 1, 2, 3, 4, or one of the
            accepted resolution and format symbolic constants. ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "width")
           " or "
           (var "height")
           " is less than 0
            or greater than 2 + "
           (code "GL_MAX_TEXTURE_SIZE")
           ". ")
     (para (code "GL_INVALID_VALUE")
           " is generated if non-power-of-two textures are not supported and the "
           (var "width")
           " or "
           (var "height")
           " cannot be represented as "
           (math "2"
                 "^"
                 (var "k")
                 "+"
                 "2"
                 "\u2061"
                 "("
                 (var "border")
                 ","
                 ")")
           "
for some
            integer value of "
           (var "k")
           ". ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "border")
           " is not 0 or 1. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (var "type")
           " is one of "
           (code "GL_UNSIGNED_BYTE_3_3_2")
           ", "
           (code "GL_UNSIGNED_BYTE_2_3_3_REV")
           ", "
           (code "GL_UNSIGNED_SHORT_5_6_5")
           ", or "
           (code "GL_UNSIGNED_SHORT_5_6_5_REV")
           "
and "
           (var "format")
           " is not "
           (code "GL_RGB")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (var "type")
           " is one of "
           (code "GL_UNSIGNED_SHORT_4_4_4_4")
           ", "
           (code "GL_UNSIGNED_SHORT_4_4_4_4_REV")
           ", "
           (code "GL_UNSIGNED_SHORT_5_5_5_1")
           ", "
           (code "GL_UNSIGNED_SHORT_1_5_5_5_REV")
           ", "
           (code "GL_UNSIGNED_INT_8_8_8_8")
           ", "
           (code "GL_UNSIGNED_INT_8_8_8_8_REV")
           ", "
           (code "GL_UNSIGNED_INT_10_10_10_2")
           ", or "
           (code "GL_UNSIGNED_INT_2_10_10_10_REV")
           "
and "
           (var "format")
           " is neither "
           (code "GL_RGBA")
           " nor "
           (code "GL_BGRA")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (var "target")
           " is not "
           (code "GL_TEXTURE_2D")
           " or "
           (code "GL_PROXY_TEXTURE_2D")
           " and "
           (var "internalFormat")
           " is "
           (code "GL_DEPTH_COMPONENT")
           ", "
           (code "GL_DEPTH_COMPONENT16")
           ", "
           (code "GL_DEPTH_COMPONENT24")
           ", or "
           (code "GL_DEPTH_COMPONENT32")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (var "format")
           " is "
           (code "GL_DEPTH_COMPONENT")
           " and "
           (var "internalFormat")
           " is not "
           (code "GL_DEPTH_COMPONENT")
           ", "
           (code "GL_DEPTH_COMPONENT16")
           ", "
           (code "GL_DEPTH_COMPONENT24")
           ", or "
           (code "GL_DEPTH_COMPONENT32")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (var "internalFormat")
           " is "
           (code "GL_DEPTH_COMPONENT")
           ", "
           (code "GL_DEPTH_COMPONENT16")
           ", "
           (code "GL_DEPTH_COMPONENT24")
           ", or "
           (code "GL_DEPTH_COMPONENT32")
           ", and "
           (var "format")
           " is
            not "
           (code "GL_DEPTH_COMPONENT")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target and the buffer object's data store is currently mapped. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target and the data would be unpacked from the buffer 
            object such that the memory reads required would exceed the data store size. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target and "
           (var "data")
           " is not evenly divisible 
            into the number of bytes needed to store in memory a datum indicated by "
           (var "type")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glTexImage2D")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glTexImage3D
  "glTexImage3D"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glTexImage3D"))
      (paramdef "GLenum " (parameter "target"))
      (paramdef "GLint " (parameter "level"))
      (paramdef "GLint " (parameter "internalFormat"))
      (paramdef "GLsizei " (parameter "width"))
      (paramdef "GLsizei " (parameter "height"))
      (paramdef "GLsizei " (parameter "depth"))
      (paramdef "GLint " (parameter "border"))
      (paramdef "GLenum " (parameter "format"))
      (paramdef "GLenum " (parameter "type"))
      (paramdef "const GLvoid * " (parameter "data"))))
  '(*fragment*
     (heading
       "specify a three-dimensional texture image")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "target")))
                   (para "
Specifies the target texture.
                    Must be "
                         (code "GL_TEXTURE_3D")
                         " or "
                         (code "GL_PROXY_TEXTURE_3D")
                         ". "))
            (entry (% (heading (var "level")))
                   (para "
Specifies the level-of-detail number.
                    Level 0 is the base image level.
                    Level "
                         (math (var "n"))
                         "
is the "
                         (math (var "n") "^" (var "th"))
                         "
mipmap reduction image. "))
            (entry (% (heading (var "internalFormat")))
                   (para "
Specifies the number of color components in the texture.
                    Must be 1, 2, 3, or 4, or one of the following symbolic constants: "
                         (code "GL_ALPHA")
                         ", "
                         (code "GL_ALPHA4")
                         ", "
                         (code "GL_ALPHA8")
                         ", "
                         (code "GL_ALPHA12")
                         ", "
                         (code "GL_ALPHA16")
                         ", "
                         (code "GL_COMPRESSED_ALPHA")
                         ", "
                         (code "GL_COMPRESSED_LUMINANCE")
                         ", "
                         (code "GL_COMPRESSED_LUMINANCE_ALPHA")
                         ", "
                         (code "GL_COMPRESSED_INTENSITY")
                         ", "
                         (code "GL_COMPRESSED_RGB")
                         ", "
                         (code "GL_COMPRESSED_RGBA")
                         ", "
                         (code "GL_LUMINANCE")
                         ", "
                         (code "GL_LUMINANCE4")
                         ", "
                         (code "GL_LUMINANCE8")
                         ", "
                         (code "GL_LUMINANCE12")
                         ", "
                         (code "GL_LUMINANCE16")
                         ", "
                         (code "GL_LUMINANCE_ALPHA")
                         ", "
                         (code "GL_LUMINANCE4_ALPHA4")
                         ", "
                         (code "GL_LUMINANCE6_ALPHA2")
                         ", "
                         (code "GL_LUMINANCE8_ALPHA8")
                         ", "
                         (code "GL_LUMINANCE12_ALPHA4")
                         ", "
                         (code "GL_LUMINANCE12_ALPHA12")
                         ", "
                         (code "GL_LUMINANCE16_ALPHA16")
                         ", "
                         (code "GL_INTENSITY")
                         ", "
                         (code "GL_INTENSITY4")
                         ", "
                         (code "GL_INTENSITY8")
                         ", "
                         (code "GL_INTENSITY12")
                         ", "
                         (code "GL_INTENSITY16")
                         ", "
                         (code "GL_R3_G3_B2")
                         ", "
                         (code "GL_RGB")
                         ", "
                         (code "GL_RGB4")
                         ", "
                         (code "GL_RGB5")
                         ", "
                         (code "GL_RGB8")
                         ", "
                         (code "GL_RGB10")
                         ", "
                         (code "GL_RGB12")
                         ", "
                         (code "GL_RGB16")
                         ", "
                         (code "GL_RGBA")
                         ", "
                         (code "GL_RGBA2")
                         ", "
                         (code "GL_RGBA4")
                         ", "
                         (code "GL_RGB5_A1")
                         ", "
                         (code "GL_RGBA8")
                         ", "
                         (code "GL_RGB10_A2")
                         ", "
                         (code "GL_RGBA12")
                         ", "
                         (code "GL_RGBA16")
                         ", "
                         (code "GL_SLUMINANCE")
                         ", "
                         (code "GL_SLUMINANCE8")
                         ", "
                         (code "GL_SLUMINANCE_ALPHA")
                         ", "
                         (code "GL_SLUMINANCE8_ALPHA8")
                         ", "
                         (code "GL_SRGB")
                         ", "
                         (code "GL_SRGB8")
                         ", "
                         (code "GL_SRGB_ALPHA")
                         ", or "
                         (code "GL_SRGB8_ALPHA8")
                         ". "))
            (entry (% (heading (var "width")))
                   (para "
Specifies the width of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be "
                         (math "2"
                               "^"
                               (var "n")
                               "+"
                               "2"
                               "\u2061"
                               "("
                               (var "border")
                               ","
                               ")")
                         "
for some integer "
                         (math (var "n"))
                         ".
                    All
                    implementations support 3D texture images that are at least 16 texels
                    wide. "))
            (entry (% (heading (var "height")))
                   (para "
Specifies the height of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be "
                         (math "2"
                               "^"
                               (var "m")
                               "+"
                               "2"
                               "\u2061"
                               "("
                               (var "border")
                               ","
                               ")")
                         "
for some integer "
                         (math (var "m"))
                         ".
                    All
                    implementations support 3D texture images that are at least 16 texels
                    high. "))
            (entry (% (heading (var "depth")))
                   (para "
Specifies the depth of the texture image including the border if any. If the GL version does not support non-power-of-two sizes, this value must be "
                         (math "2"
                               "^"
                               (var "k")
                               "+"
                               "2"
                               "\u2061"
                               "("
                               (var "border")
                               ","
                               ")")
                         "
for some integer "
                         (math (var "k"))
                         ".
                    All
                    implementations support 3D texture images that are at least 16 texels
                    deep. "))
            (entry (% (heading (var "border")))
                   (para "
Specifies the width of the border.
                    Must be either 0 or 1. "))
            (entry (% (heading (var "format")))
                   (para "
Specifies the format of the pixel data.
                    The following symbolic values are accepted: "
                         (code "GL_COLOR_INDEX")
                         ", "
                         (code "GL_RED")
                         ", "
                         (code "GL_GREEN")
                         ", "
                         (code "GL_BLUE")
                         ", "
                         (code "GL_ALPHA")
                         ", "
                         (code "GL_RGB")
                         ", "
                         (code "GL_BGR")
                         ", "
                         (code "GL_RGBA")
                         ", "
                         (code "GL_BGRA")
                         ", "
                         (code "GL_LUMINANCE")
                         ", and "
                         (code "GL_LUMINANCE_ALPHA")
                         ". "))
            (entry (% (heading (var "type")))
                   (para "
Specifies the data type of the pixel data.
                    The following symbolic values are accepted: "
                         (code "GL_UNSIGNED_BYTE")
                         ", "
                         (code "GL_BYTE")
                         ", "
                         (code "GL_BITMAP")
                         ", "
                         (code "GL_UNSIGNED_SHORT")
                         ", "
                         (code "GL_SHORT")
                         ", "
                         (code "GL_UNSIGNED_INT")
                         ", "
                         (code "GL_INT")
                         ", "
                         (code "GL_FLOAT")
                         ", "
                         (code "GL_UNSIGNED_BYTE_3_3_2")
                         ", "
                         (code "GL_UNSIGNED_BYTE_2_3_3_REV")
                         ", "
                         (code "GL_UNSIGNED_SHORT_5_6_5")
                         ", "
                         (code "GL_UNSIGNED_SHORT_5_6_5_REV")
                         ", "
                         (code "GL_UNSIGNED_SHORT_4_4_4_4")
                         ", "
                         (code "GL_UNSIGNED_SHORT_4_4_4_4_REV")
                         ", "
                         (code "GL_UNSIGNED_SHORT_5_5_5_1")
                         ", "
                         (code "GL_UNSIGNED_SHORT_1_5_5_5_REV")
                         ", "
                         (code "GL_UNSIGNED_INT_8_8_8_8")
                         ", "
                         (code "GL_UNSIGNED_INT_8_8_8_8_REV")
                         ", "
                         (code "GL_UNSIGNED_INT_10_10_10_2")
                         ", and "
                         (code "GL_UNSIGNED_INT_2_10_10_10_REV")
                         ". "))
            (entry (% (heading (var "data")))
                   (para "
Specifies a pointer to the image data in memory. ")))
     (heading "Description")
     (para "
Texturing maps a portion of a specified texture image
            onto each graphical primitive for which texturing is enabled.
            To enable and disable three-dimensional texturing, call "
           (code "glEnable")
           "
and "
           (code "glDisable")
           " with argument "
           (code "GL_TEXTURE_3D")
           ". ")
     (para "
To define texture images, call "
           (code "glTexImage3D")
           ".
            The arguments describe the parameters of the texture image,
            such as height,
            width, depth,
            width of the border,
            level-of-detail number
            (see "
           (code "glTexParameter")
           "),
            and number of color components provided.
            The last three arguments describe how the image is represented in memory;
            they are identical to the pixel formats used for "
           (code "glDrawPixels")
           ". ")
     (para "
If "
           (var "target")
           " is "
           (code "GL_PROXY_TEXTURE_3D")
           ", no data is read from "
           (var "data")
           ", but
            all of the texture image state is recalculated, checked for
            consistency, and checked
            against the implementation's capabilities. If the implementation cannot
            handle a texture of the requested texture size, it sets
            all of the image state to 0,
            but does not generate an error (see "
           (code "glGetError")
           "). To query for an
            entire mipmap array, use an image array level greater than or equal to
            1. ")
     (para "
If "
           (var "target")
           " is "
           (code "GL_TEXTURE_3D")
           ",
            data is read from "
           (var "data")
           " as a sequence of signed or unsigned bytes,
            shorts,
            or longs,
            or single-precision floating-point values,
            depending on "
           (var "type")
           ".
            These values are grouped into sets of one,
            two,
            three,
            or four values,
            depending on "
           (var "format")
           ",
            to form elements.
            If "
           (var "type")
           " is "
           (code "GL_BITMAP")
           ",
            the data is considered as a string of unsigned bytes (and "
           (var "format")
           " must be "
           (code "GL_COLOR_INDEX")
           ").
            Each data byte is treated as eight 1-bit elements,
            with bit ordering determined by "
           (code "GL_UNPACK_LSB_FIRST")
           "
(see "
           (code "glPixelStore")
           "). ")
     (para "
If a non-zero named buffer object is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target 
            (see "
           (code "glBindBuffer")
           ") while a texture image is
            specified, "
           (var "data")
           " is treated as a byte offset into the buffer object's data store. ")
     (para "
The first element corresponds to the lower left corner of the texture
            image.
            Subsequent elements progress left-to-right through the remaining texels
            in the lowest row of the texture image, and then in successively higher
            rows of the texture image.
            The final element corresponds to the upper right corner of the texture
            image. ")
     (para (var "format")
           " determines the composition of each element in "
           (var "data")
           ".
            It can assume one of these symbolic values: ")
     (table (% (formatter (asis)))
            (entry (% (heading (code "GL_COLOR_INDEX")))
                   (para "
Each element is a single value,
                        a color index.
                        The GL converts it to fixed point
                        (with an unspecified number of zero bits to the right of the binary point),
                        shifted left or right depending on the value and sign of "
                         (code "GL_INDEX_SHIFT")
                         ",
                        and added to "
                         (code "GL_INDEX_OFFSET")
                         "
(see "
                         (code "glPixelTransfer")
                         ").
                        The resulting index is converted to a set of color components
                        using the "
                         (code "GL_PIXEL_MAP_I_TO_R")
                         ", "
                         (code "GL_PIXEL_MAP_I_TO_G")
                         ", "
                         (code "GL_PIXEL_MAP_I_TO_B")
                         ", and "
                         (code "GL_PIXEL_MAP_I_TO_A")
                         " tables,
                        and clamped to the range [0,1]. "))
            (entry (% (heading (code "GL_RED")))
                   (para "
Each element is a single red component.
                        The GL converts it to floating point and assembles it into an RGBA element
                        by attaching 0 for green and blue, and 1 for alpha.
                        Each component is then multiplied by the signed scale factor "
                         (code "GL_c_SCALE")
                         ",
                        added to the signed bias "
                         (code "GL_c_BIAS")
                         ",
                        and clamped to the range [0,1]
                        (see "
                         (code "glPixelTransfer")
                         "). "))
            (entry (% (heading (code "GL_GREEN")))
                   (para "
Each element is a single green component.
                        The GL converts it to floating point and assembles it into an RGBA element
                        by attaching 0 for red and blue, and 1 for alpha.
                        Each component is then multiplied by the signed scale factor "
                         (code "GL_c_SCALE")
                         ",
                        added to the signed bias "
                         (code "GL_c_BIAS")
                         ",
                        and clamped to the range [0,1]
                        (see "
                         (code "glPixelTransfer")
                         "). "))
            (entry (% (heading (code "GL_BLUE")))
                   (para "
Each element is a single blue component.
                        The GL converts it to floating point and assembles it into an RGBA element
                        by attaching 0 for red and green, and 1 for alpha.
                        Each component is then multiplied by the signed scale factor "
                         (code "GL_c_SCALE")
                         ",
                        added to the signed bias "
                         (code "GL_c_BIAS")
                         ",
                        and clamped to the range [0,1]
                        (see "
                         (code "glPixelTransfer")
                         "). "))
            (entry (% (heading (code "GL_ALPHA")))
                   (para "
Each element is a single alpha component.
                        The GL converts it to floating point and assembles it into an RGBA element
                        by attaching 0 for red, green, and blue.
                        Each component is then multiplied by the signed scale factor "
                         (code "GL_c_SCALE")
                         ",
                        added to the signed bias "
                         (code "GL_c_BIAS")
                         ",
                        and clamped to the range [0,1]
                        (see "
                         (code "glPixelTransfer")
                         "). "))
            (entry (% (heading (code "GL_INTENSITY")))
                   (para "
Each element is a single intensity value.
                        The GL converts it to floating point,
                        then assembles it into an RGBA element by replicating the intensity value
                        three times for red, green, blue, and alpha.
                        Each component is then multiplied by the signed scale factor "
                         (code "GL_c_SCALE")
                         ",
                        added to the signed bias "
                         (code "GL_c_BIAS")
                         ",
                        and clamped to the range [0,1]
                        (see "
                         (code "glPixelTransfer")
                         "). "))
            (entry (% (heading (code "GL_RGB"))))
            (entry (% (heading (code "GL_BGR")))
                   (para "
Each element is an RGB triple.
                        The GL converts it to floating point and assembles it into an RGBA element
                        by attaching 1 for alpha.
                        Each component is then multiplied by the signed scale factor "
                         (code "GL_c_SCALE")
                         ",
                        added to the signed bias "
                         (code "GL_c_BIAS")
                         ",
                        and clamped to the range [0,1]
                        (see "
                         (code "glPixelTransfer")
                         "). "))
            (entry (% (heading (code "GL_RGBA"))))
            (entry (% (heading (code "GL_BGRA")))
                   (para "
Each element contains all four components.
                        Each component is multiplied by the signed scale factor "
                         (code "GL_c_SCALE")
                         ",
                        added to the signed bias "
                         (code "GL_c_BIAS")
                         ",
                        and clamped to the range [0,1]
                        (see "
                         (code "glPixelTransfer")
                         "). "))
            (entry (% (heading (code "GL_LUMINANCE")))
                   (para "
Each element is a single luminance value.
                        The GL converts it to floating point,
                        then assembles it into an RGBA element by replicating the luminance value
                        three times for red, green, and blue and attaching 1 for alpha.
                        Each component is then multiplied by the signed scale factor "
                         (code "GL_c_SCALE")
                         ",
                        added to the signed bias "
                         (code "GL_c_BIAS")
                         ",
                        and clamped to the range [0,1]
                        (see "
                         (code "glPixelTransfer")
                         "). "))
            (entry (% (heading (code "GL_LUMINANCE_ALPHA")))
                   (para "
Each element is a luminance/alpha pair.
                        The GL converts it to floating point,
                        then assembles it into an RGBA element by replicating the luminance value
                        three times for red, green, and blue.
                        Each component is then multiplied by the signed scale factor "
                         (code "GL_c_SCALE")
                         ",
                        added to the signed bias "
                         (code "GL_c_BIAS")
                         ",
                        and clamped to the range [0,1] (see "
                         (code "glPixelTransfer")
                         "). ")))
     (para "
Refer to the "
           (code "glDrawPixels")
           " reference page for a description of
            the acceptable values for the "
           (var "type")
           " parameter. ")
     (para "
If an application wants to store the texture at a certain
            resolution or in a certain format, it can request the resolution
            and format with "
           (var "internalFormat")
           ". The GL will choose an internal
            representation that closely approximates that requested by "
           (var "internalFormat")
           ", but
            it may not match exactly.
            (The representations specified by "
           (code "GL_LUMINANCE")
           ", "
           (code "GL_LUMINANCE_ALPHA")
           ", "
           (code "GL_RGB")
           ",
            and "
           (code "GL_RGBA")
           " must match exactly. The numeric values 1, 2, 3, and 4
            may also be used to specify the above representations.) ")
     (para "
If the "
           (var "internalFormat")
           " parameter is one of the generic compressed formats,\t"
           (code "GL_COMPRESSED_ALPHA")
           ",\t"
           (code "GL_COMPRESSED_INTENSITY")
           ",\t"
           (code "GL_COMPRESSED_LUMINANCE")
           ",\t"
           (code "GL_COMPRESSED_LUMINANCE_ALPHA")
           ",\t"
           (code "GL_COMPRESSED_RGB")
           ", or\t"
           (code "GL_COMPRESSED_RGBA")
           ", the GL will replace the internal format with the symbolic constant for a specific internal format and compress the texture before storage.  If no corresponding internal format is available, or the GL can not compress that image for any reason, the internal format is instead replaced with a corresponding base internal format. ")
     (para "
If the "
           (var "internalFormat")
           " parameter is "
           (code "GL_SRGB")
           ",\t"
           (code "GL_SRGB8")
           ",\t"
           (code "GL_SRGB_ALPHA")
           ",\t"
           (code "GL_SRGB8_ALPHA8")
           ",\t"
           (code "GL_SLUMINANCE")
           ",\t"
           (code "GL_SLUMINANCE8")
           ",\t"
           (code "GL_SLUMINANCE_ALPHA")
           ", or\t"
           (code "GL_SLUMINANCE8_ALPHA8")
           ", the texture is treated as if the red, green, blue, or luminance components are encoded in the sRGB color space.    Any alpha component is left unchanged.  The conversion from the sRGB encoded component\t"
           (math (var "c") "_" (var "s"))
           "
to a linear component\t"
           (math (var "c") "_" (var "l"))
           "
is:\t")
     (para (math (var "c")
                 "_"
                 (var "l")
                 "="
                 "{"
                 "("
                 (var "c")
                 "_"
                 (var "s")
                 "/"
                 "12.92"
                 " "
                 " "
                 "if"
                 " "
                 (var "c")
                 "_"
                 (var "s")
                 "≤"
                 "0.04045"
                 ")"
                 ", "
                 "("
                 "("
                 (code "c")
                 "_"
                 (code "s")
                 "+"
                 "0.055"
                 "/"
                 "1.055"
                 ")"
                 "^"
                 "2.4"
                 " "
                 " "
                 "if"
                 " "
                 (var "c")
                 "_"
                 (var "s")
                 ">"
                 "0.04045"
                 ")"))
     (para "
Assume\t"
           (math (var "c") "_" (var "s"))
           "
is the sRGB component in the range [0,1]. ")
     (para "
Use the "
           (code "GL_PROXY_TEXTURE_3D")
           " target to try out a resolution and
            format. The implementation will
            update and recompute its best match for the requested storage resolution
            and format. To then query this state, call "
           (code "glGetTexLevelParameter")
           ".
            If the texture cannot be accommodated, texture state is set to 0. ")
     (para "
A one-component texture image uses only the red component of the RGBA
            color extracted from "
           (var "data")
           ".
            A two-component image uses the R and A values.
            A three-component image uses the R, G, and B values.
            A four-component image uses all of the RGBA components. ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "target")
           " is not "
           (code "GL_TEXTURE_3D")
           "
or "
           (code "GL_PROXY_TEXTURE_3D")
           ". ")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "format")
           " is not an accepted
            format constant.  Format constants other than "
           (code "GL_STENCIL_INDEX")
           " and "
           (code "GL_DEPTH_COMPONENT")
           "
are accepted. ")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "type")
           " is not a type constant. ")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "type")
           " is "
           (code "GL_BITMAP")
           " and "
           (var "format")
           " is not "
           (code "GL_COLOR_INDEX")
           ". ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "level")
           " is less than 0. ")
     (para (code "GL_INVALID_VALUE")
           " may be generated if "
           (var "level")
           " is greater than "
           (math (var "log")
                 "_"
                 "2"
                 "\u2061"
                 "("
                 (var "max")
                 ","
                 ")")
           ",
            where "
           (var "max")
           " is the returned value of "
           (code "GL_MAX_TEXTURE_SIZE")
           ". ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "internalFormat")
           " is not 1, 2, 3, 4, or one of the
            accepted resolution and format symbolic constants. ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "width")
           ", "
           (var "height")
           ", or "
           (var "depth")
           " is less than 0 or greater than 2 + "
           (code "GL_MAX_TEXTURE_SIZE")
           ". ")
     (para (code "GL_INVALID_VALUE")
           " is generated if non-power-of-two textures are not supported and the "
           (var "width")
           ", "
           (var "height")
           ", or "
           (var "depth")
           " cannot be represented as "
           (math "2"
                 "^"
                 (var "k")
                 "+"
                 "2"
                 "\u2061"
                 "("
                 (var "border")
                 ","
                 ")")
           "
for some
            integer value of "
           (var "k")
           ". ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "border")
           " is not 0 or 1. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (var "type")
           " is one of "
           (code "GL_UNSIGNED_BYTE_3_3_2")
           ", "
           (code "GL_UNSIGNED_BYTE_2_3_3_REV")
           ", "
           (code "GL_UNSIGNED_SHORT_5_6_5")
           ", or "
           (code "GL_UNSIGNED_SHORT_5_6_5_REV")
           "
and "
           (var "format")
           " is not "
           (code "GL_RGB")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (var "type")
           " is one of "
           (code "GL_UNSIGNED_SHORT_4_4_4_4")
           ", "
           (code "GL_UNSIGNED_SHORT_4_4_4_4_REV")
           ", "
           (code "GL_UNSIGNED_SHORT_5_5_5_1")
           ", "
           (code "GL_UNSIGNED_SHORT_1_5_5_5_REV")
           ", "
           (code "GL_UNSIGNED_INT_8_8_8_8")
           ", "
           (code "GL_UNSIGNED_INT_8_8_8_8_REV")
           ", "
           (code "GL_UNSIGNED_INT_10_10_10_2")
           ", or "
           (code "GL_UNSIGNED_INT_2_10_10_10_REV")
           "
and "
           (var "format")
           " is neither "
           (code "GL_RGBA")
           " nor "
           (code "GL_BGRA")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (var "format")
           " or "
           (var "internalFormat")
           " is "
           (code "GL_DEPTH_COMPONENT")
           ", "
           (code "GL_DEPTH_COMPONENT16")
           ", "
           (code "GL_DEPTH_COMPONENT24")
           ", or "
           (code "GL_DEPTH_COMPONENT32")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target and the buffer object's data store is currently mapped. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target and the data would be unpacked from the buffer 
            object such that the memory reads required would exceed the data store size. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target and "
           (var "data")
           " is not evenly divisible 
            into the number of bytes needed to store in memory a datum indicated by "
           (var "type")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glTexImage3D")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glTexParameter
  "glTexParameter"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glTexParameterf"))
      (paramdef "GLenum " (parameter "target"))
      (paramdef "GLenum " (parameter "pname"))
      (paramdef "GLfloat " (parameter "param"))))
  '(*fragment*
     (heading "set texture parameters")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "target")))
                   (para "
Specifies the target texture,
                    which must be either "
                         (code "GL_TEXTURE_1D")
                         ", "
                         (code "GL_TEXTURE_2D")
                         ", "
                         (code "GL_TEXTURE_3D")
                         ", or "
                         (code "GL_TEXTURE_CUBE_MAP")
                         ". "))
            (entry (% (heading (var "pname")))
                   (para "
Specifies the symbolic name of a single-valued texture parameter. "
                         (var "pname")
                         " can be one of the following: "
                         (code "GL_TEXTURE_MIN_FILTER")
                         ", "
                         (code "GL_TEXTURE_MAG_FILTER")
                         ", "
                         (code "GL_TEXTURE_MIN_LOD")
                         ", "
                         (code "GL_TEXTURE_MAX_LOD")
                         ", "
                         (code "GL_TEXTURE_BASE_LEVEL")
                         ", "
                         (code "GL_TEXTURE_MAX_LEVEL")
                         ", "
                         (code "GL_TEXTURE_WRAP_S")
                         ", "
                         (code "GL_TEXTURE_WRAP_T")
                         ", "
                         (code "GL_TEXTURE_WRAP_R")
                         ", "
                         (code "GL_TEXTURE_PRIORITY")
                         ", "
                         (code "GL_TEXTURE_COMPARE_MODE")
                         ", "
                         (code "GL_TEXTURE_COMPARE_FUNC")
                         ", "
                         (code "GL_DEPTH_TEXTURE_MODE")
                         ", or "
                         (code "GL_GENERATE_MIPMAP")
                         ". "))
            (entry (% (heading (var "param")))
                   (para "
Specifies the value of "
                         (var "pname")
                         ". ")))
     (heading "Description")
     (para "
Texture mapping is a technique that applies an image onto an object's surface
            as if the image were a decal or cellophane shrink-wrap.
            The image is created in texture space,
            with an 
            ("
           (math (var "s"))
           ", "
           (math (var "t"))
           ")
            coordinate system.
            A texture is a one- or two-dimensional image and a set of parameters
            that determine how samples are derived from the image. ")
     (para (code "glTexParameter")
           " assigns the value or values in "
           (var "params")
           " to the texture parameter
            specified as "
           (var "pname")
           ". "
           (var "target")
           " defines the target texture,
            either "
           (code "GL_TEXTURE_1D")
           ", "
           (code "GL_TEXTURE_2D")
           ", or "
           (code "GL_TEXTURE_3D")
           ".
            The following symbols are accepted in "
           (var "pname")
           ": ")
     (table (% (formatter (asis)))
            (entry (% (heading (code "GL_TEXTURE_MIN_FILTER")))
                   (para "
The texture minifying function is used whenever the pixel being textured
                        maps to an area greater than one texture element.
                        There are six defined minifying functions.
                        Two of them use the nearest one or nearest four texture elements
                        to compute the texture value.
                        The other four use mipmaps. ")
                   (para "
A mipmap is an ordered set of arrays representing the same image
                        at progressively lower resolutions.
                        If the texture has dimensions "
                         (math "2" "^" (var "n") "×" "2" "^" (var "m"))
                         ",
                        there are "
                         (math (var "max")
                               "\u2061"
                               "("
                               (var "n")
                               ","
                               (var "m")
                               ")"
                               "+"
                               "1")
                         "
mipmaps.
                        The first mipmap is the original texture,
                        with dimensions "
                         (math "2" "^" (var "n") "×" "2" "^" (var "m"))
                         ".
                        Each subsequent mipmap has dimensions "
                         (math "2"
                               "^"
                               (var "k")
                               "-"
                               "1"
                               ","
                               "×"
                               "2"
                               "^"
                               (var "l")
                               "-"
                               "1"
                               ",")
                         ",
                        where "
                         (math "2" "^" (var "k") "×" "2" "^" (var "l"))
                         "
are the dimensions of the previous mipmap,
                        until either "
                         (math (var "k") "=" "0")
                         "
or "
                         (math (var "l") "=" "0")
                         ".
                        At that point,
                        subsequent mipmaps have dimension "
                         (math "1" "×" "2" "^" (var "l") "-" "1" ",")
                         "
or "
                         (math "2" "^" (var "k") "-" "1" "," "×" "1")
                         "
until the final mipmap,
                        which has dimension "
                         (math "1" "×" "1")
                         ".
                        To define the mipmaps, call "
                         (code "glTexImage1D")
                         ", "
                         (code "glTexImage2D")
                         ", "
                         (code "glTexImage3D")
                         ", "
                         (code "glCopyTexImage1D")
                         ", or "
                         (code "glCopyTexImage2D")
                         "
with the "
                         (var "level")
                         " argument indicating the order of the mipmaps.
                        Level 0 is the original texture;
                        level "
                         (math (var "max")
                               "\u2061"
                               "("
                               (var "n")
                               ","
                               (var "m")
                               ")")
                         "
is the final "
                         (math "1" "×" "1")
                         "
mipmap. ")
                   (para (var "params")
                         " supplies a function for minifying the texture as one of the
                        following: ")
                   (para "
As more texture elements are sampled in the minification process,
                        fewer aliasing artifacts will be apparent.
                        While the "
                         (code "GL_NEAREST")
                         " and "
                         (code "GL_LINEAR")
                         " minification functions can be
                        faster than the other four,
                        they sample only one or four texture elements to determine the texture value
                        of the pixel being rendered and can produce moire patterns
                        or ragged transitions.
                        The initial value of "
                         (code "GL_TEXTURE_MIN_FILTER")
                         " is "
                         (code "GL_NEAREST_MIPMAP_LINEAR")
                         ". "))
            (entry (% (heading (code "GL_TEXTURE_MAG_FILTER")))
                   (para "
The texture magnification function is used when the pixel being textured
                        maps to an area less than or equal to one texture element.
                        It sets the texture magnification function to either "
                         (code "GL_NEAREST")
                         "
or "
                         (code "GL_LINEAR")
                         " (see below). "
                         (code "GL_NEAREST")
                         " is generally faster
                        than "
                         (code "GL_LINEAR")
                         ",
                        but it can produce textured images with sharper edges
                        because the transition between texture elements is not as smooth.
                        The initial value of "
                         (code "GL_TEXTURE_MAG_FILTER")
                         " is "
                         (code "GL_LINEAR")
                         ". "
                         (para))))
     (table (% (formatter (asis)))
            (entry (% (heading (code "GL_NEAREST")))
                   (para "
Returns the value of the texture element that is nearest
                                        (in Manhattan distance)
                                        to the center of the pixel being textured. "))
            (entry (% (heading (code "GL_LINEAR")))
                   (para "
Returns the weighted average of the four texture elements
                                        that are closest to the center of the pixel being textured.
                                        These can include border texture elements,
                                        depending on the values of "
                         (code "GL_TEXTURE_WRAP_S")
                         " and "
                         (code "GL_TEXTURE_WRAP_T")
                         ",
                                        and on the exact mapping. "))
            (entry (% (heading (code "GL_NEAREST_MIPMAP_NEAREST")))
                   (para "
Chooses the mipmap that most closely matches the size of the pixel
                                        being textured and uses the "
                         (code "GL_NEAREST")
                         " criterion
                                        (the texture element nearest to the center of the pixel)
                                        to produce a texture value. "))
            (entry (% (heading (code "GL_LINEAR_MIPMAP_NEAREST")))
                   (para "
Chooses the mipmap that most closely matches the size of the pixel
                                        being textured and uses the "
                         (code "GL_LINEAR")
                         " criterion
                                        (a weighted average of the four texture elements that are closest
                                        to the center of the pixel)
                                        to produce a texture value. "))
            (entry (% (heading (code "GL_NEAREST_MIPMAP_LINEAR")))
                   (para "
Chooses the two mipmaps that most closely match the size of the pixel
                                        being textured and uses the "
                         (code "GL_NEAREST")
                         " criterion
                                        (the texture element nearest to the center of the pixel)
                                        to produce a texture value from each mipmap.
                                        The final texture value is a weighted average of those two values. "))
            (entry (% (heading (code "GL_LINEAR_MIPMAP_LINEAR")))
                   (para "
Chooses the two mipmaps that most closely match the size of the pixel
                                        being textured and uses the "
                         (code "GL_LINEAR")
                         " criterion
                                        (a weighted average of the four texture elements that are closest
                                        to the center of the pixel)
                                        to produce a texture value from each mipmap.
                                        The final texture value is a weighted average of those two values. ")))
     (table (% (formatter (asis)))
            (entry (% (heading (code "GL_NEAREST")))
                   (para "
Returns the value of the texture element that is nearest
                                        (in Manhattan distance)
                                        to the center of the pixel being textured. "))
            (entry (% (heading (code "GL_LINEAR")))
                   (para "
Returns the weighted average of the four texture elements
                                        that are closest to the center of the pixel being textured.
                                        These can include border texture elements,
                                        depending on the values of "
                         (code "GL_TEXTURE_WRAP_S")
                         " and "
                         (code "GL_TEXTURE_WRAP_T")
                         ",
                                        and on the exact mapping. ")))
     (para)
     (table (% (formatter (asis)))
            (entry (% (heading (code "GL_TEXTURE_MIN_LOD")))
                   (para "
Sets the minimum level-of-detail parameter.  This floating-point value
                        limits the selection of highest resolution mipmap (lowest mipmap
                        level). The initial value is -1000. ")))
     (para)
     (table (% (formatter (asis)))
            (entry (% (heading (code "GL_TEXTURE_MAX_LOD")))
                   (para "
Sets the maximum level-of-detail parameter.  This floating-point value
                        limits the selection of the lowest resolution mipmap (highest mipmap
                        level). The initial value is 1000. ")))
     (para)
     (table (% (formatter (asis)))
            (entry (% (heading (code "GL_TEXTURE_BASE_LEVEL")))
                   (para "
Specifies the index of the lowest defined mipmap level. This is an
                        integer value. The initial value is 0. ")))
     (para)
     (table (% (formatter (asis)))
            (entry (% (heading (code "GL_TEXTURE_MAX_LEVEL")))
                   (para "
Sets the index of the highest defined mipmap level. This is an integer
                        value. The initial value is 1000. ")))
     (para)
     (table (% (formatter (asis)))
            (entry (% (heading (code "GL_TEXTURE_WRAP_S")))
                   (para "
Sets the wrap parameter for texture coordinate "
                         (math (var "s"))
                         "
to either "
                         (code "GL_CLAMP")
                         ", "
                         (code "GL_CLAMP_TO_BORDER")
                         ", "
                         (code "GL_CLAMP_TO_EDGE")
                         ", "
                         (code "GL_MIRRORED_REPEAT")
                         ", or "
                         (code "GL_REPEAT")
                         ". "
                         (code "GL_CLAMP")
                         " causes "
                         (math (var "s"))
                         "
coordinates to be clamped to the
                        range [0,1] and is useful for preventing wrapping artifacts when mapping a
                        single image onto an object. "
                         (code "GL_CLAMP_TO_BORDER")
                         " causes the "
                         (math (var "s"))
                         "
coordinate to be clamped to the range "
                         (math "["
                               "-1"
                               "/"
                               "2"
                               (var "N")
                               ","
                               ","
                               "1"
                               "+"
                               "1"
                               "/"
                               "2"
                               (var "N")
                               ","
                               "]")
                         ",
                        where "
                         (math (var "N"))
                         "
is the size of the texture in the direction of
                        clamping."
                         (code "GL_CLAMP_TO_EDGE")
                         " causes "
                         (math (var "s"))
                         "
coordinates to be clamped to the
                        range "
                         (math "["
                               "1"
                               "/"
                               "2"
                               (var "N")
                               ","
                               ","
                               "1"
                               "-"
                               "1"
                               "/"
                               "2"
                               (var "N")
                               ","
                               "]")
                         ",
                        where "
                         (math (var "N"))
                         "
is the size
                        of the texture in the direction of clamping. "
                         (code "GL_REPEAT")
                         " causes the
                        integer part of the "
                         (math (var "s"))
                         "
coordinate to be ignored; the GL uses only the
                        fractional part, thereby creating a repeating pattern. "
                         (code "GL_MIRRORED_REPEAT")
                         " causes the "
                         (math (var "s"))
                         "
coordinate to be set to the
                        fractional part of the texture coordinate if the integer part of "
                         (math (var "s"))
                         "
is
                        even; if the integer part of "
                         (math (var "s"))
                         "
is odd, then the "
                         (math (var "s"))
                         "
texture coordinate is
                        set to "
                         (math "1"
                               "-"
                               (var "frac")
                               "\u2061"
                               "("
                               (var "s")
                               ","
                               ")")
                         ",
                        where "
                         (math (var "frac")
                               "\u2061"
                               "("
                               (var "s")
                               ","
                               ")")
                         "
represents the fractional part of "
                         (math (var "s"))
                         ".
                        Border texture
                        elements are accessed only if wrapping is set to "
                         (code "GL_CLAMP")
                         " or "
                         (code "GL_CLAMP_TO_BORDER")
                         ".  Initially, "
                         (code "GL_TEXTURE_WRAP_S")
                         " is set to "
                         (code "GL_REPEAT")
                         ". ")))
     (para)
     (table (% (formatter (asis)))
            (entry (% (heading (code "GL_TEXTURE_WRAP_T")))
                   (para "
Sets the wrap parameter for texture coordinate "
                         (math (var "t"))
                         "
to either "
                         (code "GL_CLAMP")
                         ", "
                         (code "GL_CLAMP_TO_BORDER")
                         ", "
                         (code "GL_CLAMP_TO_EDGE")
                         ", "
                         (code "GL_MIRRORED_REPEAT")
                         ", or "
                         (code "GL_REPEAT")
                         ".  See the discussion under "
                         (code "GL_TEXTURE_WRAP_S")
                         ".
                        Initially, "
                         (code "GL_TEXTURE_WRAP_T")
                         " is set to "
                         (code "GL_REPEAT")
                         ". "))
            (entry (% (heading (code "GL_TEXTURE_WRAP_R")))
                   (para "
Sets the wrap parameter for texture coordinate "
                         (math (var "r"))
                         "
to either "
                         (code "GL_CLAMP")
                         ", "
                         (code "GL_CLAMP_TO_BORDER")
                         ", "
                         (code "GL_CLAMP_TO_EDGE")
                         ", "
                         (code "GL_MIRRORED_REPEAT")
                         ", or "
                         (code "GL_REPEAT")
                         ".  See the discussion under "
                         (code "GL_TEXTURE_WRAP_S")
                         ".
                        Initially, "
                         (code "GL_TEXTURE_WRAP_R")
                         " is set to "
                         (code "GL_REPEAT")
                         ". "))
            (entry (% (heading (code "GL_TEXTURE_BORDER_COLOR")))
                   (para "
Sets a border color. "
                         (var "params")
                         " contains four values that comprise the RGBA
                        color of the texture border.  Integer color components are interpreted
                        linearly such that the most positive integer maps to 1.0, and the most
                        negative integer maps to -1.0.  The values are clamped to the range [0,1]
                        when they are specified.  Initially, the border color is (0, 0, 0, 0). "))
            (entry (% (heading (code "GL_TEXTURE_PRIORITY")))
                   (para "
Specifies the texture residence priority of the currently bound texture.
                        Permissible values are in the range "
                         (math "[" "0" "," "1" "]")
                         ".
                        See "
                         (code "glPrioritizeTextures")
                         " and "
                         (code "glBindTexture")
                         " for more information. "))
            (entry (% (heading (code "GL_TEXTURE_COMPARE_MODE")))
                   (para "
Specifies the texture comparison mode for currently bound depth textures.
                        That is, a texture whose internal format is "
                         (code "GL_DEPTH_COMPONENT_*")
                         "; see "
                         (code "glTexImage2D")
                         ")
                        Permissible values are: "))
            (entry (% (heading (code "GL_TEXTURE_COMPARE_FUNC")))
                   (para "
Specifies the comparison operator used when "
                         (code "GL_TEXTURE_COMPARE_MODE")
                         " is
                        set to "
                         (code "GL_COMPARE_R_TO_TEXTURE")
                         ".  Permissible values are: "
                         "
where "
                         (math (var "r"))
                         "
is the current interpolated texture coordinate, and "
                         (math (var "D") "_" (var "t"))
                         "
is the depth texture value sampled from the currently bound depth texture. "
                         (math (var "result"))
                         "
is assigned to the either the luminance, intensity, or alpha (as
                        specified by "
                         (code "GL_DEPTH_TEXTURE_MODE")
                         ".) "))
            (entry (% (heading (code "GL_DEPTH_TEXTURE_MODE")))
                   (para "
Specifies a single symbolic constant indicating how depth values should be
                        treated during filtering and texture application.  Accepted values are "
                         (code "GL_LUMINANCE")
                         ", "
                         (code "GL_INTENSITY")
                         ", and "
                         (code "GL_ALPHA")
                         ".  The initial value
                        is "
                         (code "GL_LUMINANCE")
                         ". "))
            (entry (% (heading (code "GL_GENERATE_MIPMAP")))
                   (para "
Specifies a boolean value that indicates if all levels of a mipmap array
                        should be automatically updated when any modification to the base level
                        mipmap is done.  The initial value is "
                         (code "GL_FALSE")
                         ". ")))
     (table (% (formatter (asis)))
            (entry (% (heading (code "GL_COMPARE_R_TO_TEXTURE")))
                   (para "
Specifies that the interpolated and clamped "
                         (math (var "r"))
                         "
texture coordinate should
                                        be compared to the value in the currently bound depth texture.  See the
                                        discussion of "
                         (code "GL_TEXTURE_COMPARE_FUNC")
                         " for details of how the comparison
                                        is evaluated.  The result of the comparison is assigned to luminance,
                                        intensity, or alpha (as specified by "
                         (code "GL_DEPTH_TEXTURE_MODE")
                         "). "))
            (entry (% (heading (code "GL_NONE")))
                   (para "
Specifies that the luminance, intensity, or alpha (as specified by "
                         (code "GL_DEPTH_TEXTURE_MODE")
                         ") should be assigned the
                                        appropriate value from the currently bound depth texture. ")))
     (table (% (formatter (asis)))
            (entry (% (heading (strong "Texture Comparison Function")))
                   (para (strong "Computed result")))
            (entry (% (heading (code "GL_LEQUAL")))
                   (para (math (var "result")
                               "="
                               "{"
                               "("
                               "1.0"
                               ")"
                               ", "
                               "("
                               "0.0"
                               ")"
                               "\u2062\xa0"
                               "("
                               (var "r")
                               "<="
                               (var "D")
                               "_"
                               (var "t")
                               ","
                               ")"
                               ", "
                               "("
                               (var "r")
                               ">"
                               (var "D")
                               "_"
                               (var "t")
                               ","
                               ")"
                               ",")))
            (entry (% (heading (code "GL_GEQUAL")))
                   (para (math (var "result")
                               "="
                               "{"
                               "("
                               "1.0"
                               ")"
                               ", "
                               "("
                               "0.0"
                               ")"
                               "\u2062\xa0"
                               "("
                               (var "r")
                               ">="
                               (var "D")
                               "_"
                               (var "t")
                               ","
                               ")"
                               ", "
                               "("
                               (var "r")
                               "<"
                               (var "D")
                               "_"
                               (var "t")
                               ","
                               ")"
                               ",")))
            (entry (% (heading (code "GL_LESS")))
                   (para (math (var "result")
                               "="
                               "{"
                               "("
                               "1.0"
                               ")"
                               ", "
                               "("
                               "0.0"
                               ")"
                               "\u2062\xa0"
                               "("
                               (var "r")
                               "<"
                               (var "D")
                               "_"
                               (var "t")
                               ","
                               ")"
                               ", "
                               "("
                               (var "r")
                               ">="
                               (var "D")
                               "_"
                               (var "t")
                               ","
                               ")"
                               ",")))
            (entry (% (heading (code "GL_GREATER")))
                   (para (math (var "result")
                               "="
                               "{"
                               "("
                               "1.0"
                               ")"
                               ", "
                               "("
                               "0.0"
                               ")"
                               "\u2062\xa0"
                               "("
                               (var "r")
                               ">"
                               (var "D")
                               "_"
                               (var "t")
                               ","
                               ")"
                               ", "
                               "("
                               (var "r")
                               "<="
                               (var "D")
                               "_"
                               (var "t")
                               ","
                               ")"
                               ",")))
            (entry (% (heading (code "GL_EQUAL")))
                   (para (math (var "result")
                               "="
                               "{"
                               "("
                               "1.0"
                               ")"
                               ", "
                               "("
                               "0.0"
                               ")"
                               "\u2062\xa0"
                               "("
                               (var "r")
                               "="
                               (var "D")
                               "_"
                               (var "t")
                               ","
                               ")"
                               ", "
                               "("
                               (var "r")
                               "≠"
                               (var "D")
                               "_"
                               (var "t")
                               ","
                               ")"
                               ",")))
            (entry (% (heading (code "GL_NOTEQUAL")))
                   (para (math (var "result")
                               "="
                               "{"
                               "("
                               "1.0"
                               ")"
                               ", "
                               "("
                               "0.0"
                               ")"
                               "\u2062\xa0"
                               "("
                               (var "r")
                               "≠"
                               (var "D")
                               "_"
                               (var "t")
                               ","
                               ")"
                               ", "
                               "("
                               (var "r")
                               "="
                               (var "D")
                               "_"
                               (var "t")
                               ","
                               ")"
                               ",")))
            (entry (% (heading (code "GL_ALWAYS")))
                   (para (math (var "result") "=" (code "1.0"))))
            (entry (% (heading (code "GL_NEVER")))
                   (para (math (var "result") "=" (code "0.0")))))
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "target")
           " or "
           (var "pname")
           " is not
            one of the accepted defined values. ")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "params")
           " should have a defined
            constant value (based on the value of "
           (var "pname")
           ") and does not. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glTexParameter")
           " is executed between the
            execution of "
           (code "glBegin")
           " and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glTexSubImage1D
  "glTexSubImage1D"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glTexSubImage1D"))
      (paramdef "GLenum " (parameter "target"))
      (paramdef "GLint " (parameter "level"))
      (paramdef "GLint " (parameter "xoffset"))
      (paramdef "GLsizei " (parameter "width"))
      (paramdef "GLenum " (parameter "format"))
      (paramdef "GLenum " (parameter "type"))
      (paramdef "const GLvoid * " (parameter "data"))))
  '(*fragment*
     (heading
       "specify a one-dimensional texture subimage")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "target")))
                   (para "
Specifies the target texture.
                    Must be "
                         (code "GL_TEXTURE_1D")
                         ". "))
            (entry (% (heading (var "level")))
                   (para "
Specifies the level-of-detail number.
                    Level 0 is the base image level.
                    Level "
                         (var "n")
                         " is the "
                         (var "n")
                         "th mipmap reduction image. "))
            (entry (% (heading (var "xoffset")))
                   (para "
Specifies a texel offset in the x direction within the texture array. "))
            (entry (% (heading (var "width")))
                   (para "
Specifies the width of the texture subimage. "))
            (entry (% (heading (var "format")))
                   (para "
Specifies the format of the pixel data.
                    The following symbolic values are accepted: "
                         (code "GL_COLOR_INDEX")
                         ", "
                         (code "GL_RED")
                         ", "
                         (code "GL_GREEN")
                         ", "
                         (code "GL_BLUE")
                         ", "
                         (code "GL_ALPHA")
                         ", "
                         (code "GL_RGB")
                         ", "
                         (code "GL_BGR")
                         ", "
                         (code "GL_RGBA")
                         ", "
                         (code "GL_BGRA")
                         ", "
                         (code "GL_LUMINANCE")
                         ", and "
                         (code "GL_LUMINANCE_ALPHA")
                         ". "))
            (entry (% (heading (var "type")))
                   (para "
Specifies the data type of the pixel data.
                    The following symbolic values are accepted: "
                         (code "GL_UNSIGNED_BYTE")
                         ", "
                         (code "GL_BYTE")
                         ", "
                         (code "GL_BITMAP")
                         ", "
                         (code "GL_UNSIGNED_SHORT")
                         ", "
                         (code "GL_SHORT")
                         ", "
                         (code "GL_UNSIGNED_INT")
                         ", "
                         (code "GL_INT")
                         ", "
                         (code "GL_FLOAT")
                         ", "
                         (code "GL_UNSIGNED_BYTE_3_3_2")
                         ", "
                         (code "GL_UNSIGNED_BYTE_2_3_3_REV")
                         ", "
                         (code "GL_UNSIGNED_SHORT_5_6_5")
                         ", "
                         (code "GL_UNSIGNED_SHORT_5_6_5_REV")
                         ", "
                         (code "GL_UNSIGNED_SHORT_4_4_4_4")
                         ", "
                         (code "GL_UNSIGNED_SHORT_4_4_4_4_REV")
                         ", "
                         (code "GL_UNSIGNED_SHORT_5_5_5_1")
                         ", "
                         (code "GL_UNSIGNED_SHORT_1_5_5_5_REV")
                         ", "
                         (code "GL_UNSIGNED_INT_8_8_8_8")
                         ", "
                         (code "GL_UNSIGNED_INT_8_8_8_8_REV")
                         ", "
                         (code "GL_UNSIGNED_INT_10_10_10_2")
                         ", and "
                         (code "GL_UNSIGNED_INT_2_10_10_10_REV")
                         ". "))
            (entry (% (heading (var "data")))
                   (para "
Specifies a pointer to the image data in memory. ")))
     (heading "Description")
     (para "
Texturing maps a portion of a specified texture image
            onto each graphical primitive for which texturing is enabled.
            To enable or disable one-dimensional texturing, call "
           (code "glEnable")
           "
and "
           (code "glDisable")
           " with argument "
           (code "GL_TEXTURE_1D")
           ". ")
     (para (code "glTexSubImage1D")
           " redefines a contiguous subregion of an existing one-dimensional
            texture image.
            The texels referenced by "
           (var "data")
           " replace the portion of the
            existing texture array with x indices "
           (var "xoffset")
           " and "
           (math (var "xoffset") "+" (var "width") "-" "1")
           ",
            inclusive.
            This region may not include any texels outside the range of the
            texture array as it was originally specified.
            It is not an error to specify a subtexture with width of 0, but
            such a specification has no effect. ")
     (para "
If a non-zero named buffer object is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target 
            (see "
           (code "glBindBuffer")
           ") while a texture image is
            specified, "
           (var "data")
           " is treated as a byte offset into the buffer object's data store. ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "target")
           " is not one of the
            allowable values. ")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "format")
           " is not an accepted
            format constant. ")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "type")
           " is not a type constant. ")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "type")
           " is "
           (code "GL_BITMAP")
           " and "
           (var "format")
           " is not "
           (code "GL_COLOR_INDEX")
           ". ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "level")
           " is less than 0. ")
     (para (code "GL_INVALID_VALUE")
           " may be generated if "
           (var "level")
           " is greater
            than "
           (math (var "log") "_" "2")
           (var "max")
           ",
            where "
           (var "max")
           " is the returned value of "
           (code "GL_MAX_TEXTURE_SIZE")
           ". ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (math (var "xoffset") "<" "-" (var "b"))
           ",
            or if "
           (math "("
                 (var "xoffset")
                 "+"
                 (var "width")
                 ","
                 ")"
                 ">"
                 "("
                 (var "w")
                 "-"
                 (var "b")
                 ","
                 ")")
           ",
            where "
           (math (var "w"))
           "
is the "
           (code "GL_TEXTURE_WIDTH")
           ", and "
           (math (var "b"))
           "
is
            the width of the "
           (code "GL_TEXTURE_BORDER")
           "
of the texture image being modified.
            Note that "
           (math (var "w"))
           "
includes twice the border width. ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "width")
           " is less than 0. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if the texture array has not
            been defined by a previous "
           (code "glTexImage1D")
           " operation. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (var "type")
           " is one of "
           (code "GL_UNSIGNED_BYTE_3_3_2")
           ", "
           (code "GL_UNSIGNED_BYTE_2_3_3_REV")
           ", "
           (code "GL_UNSIGNED_SHORT_5_6_5")
           ", or "
           (code "GL_UNSIGNED_SHORT_5_6_5_REV")
           "
and "
           (var "format")
           " is not "
           (code "GL_RGB")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (var "type")
           " is one of "
           (code "GL_UNSIGNED_SHORT_4_4_4_4")
           ", "
           (code "GL_UNSIGNED_SHORT_4_4_4_4_REV")
           ", "
           (code "GL_UNSIGNED_SHORT_5_5_5_1")
           ", "
           (code "GL_UNSIGNED_SHORT_1_5_5_5_REV")
           ", "
           (code "GL_UNSIGNED_INT_8_8_8_8")
           ", "
           (code "GL_UNSIGNED_INT_8_8_8_8_REV")
           ", "
           (code "GL_UNSIGNED_INT_10_10_10_2")
           ", or "
           (code "GL_UNSIGNED_INT_2_10_10_10_REV")
           "
and "
           (var "format")
           " is neither "
           (code "GL_RGBA")
           " nor "
           (code "GL_BGRA")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target and the buffer object's data store is currently mapped. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target and the data would be unpacked from the buffer 
            object such that the memory reads required would exceed the data store size. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target and "
           (var "data")
           " is not evenly divisible 
            into the number of bytes needed to store in memory a datum indicated by "
           (var "type")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glTexSubImage1D")
           " is executed
            between the execution of "
           (code "glBegin")
           " and the corresponding
            execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glTexSubImage2D
  "glTexSubImage2D"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glTexSubImage2D"))
      (paramdef "GLenum " (parameter "target"))
      (paramdef "GLint " (parameter "level"))
      (paramdef "GLint " (parameter "xoffset"))
      (paramdef "GLint " (parameter "yoffset"))
      (paramdef "GLsizei " (parameter "width"))
      (paramdef "GLsizei " (parameter "height"))
      (paramdef "GLenum " (parameter "format"))
      (paramdef "GLenum " (parameter "type"))
      (paramdef "const GLvoid * " (parameter "data"))))
  '(*fragment*
     (heading
       "specify a two-dimensional texture subimage")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "target")))
                   (para "
Specifies the target texture.
                    Must be "
                         (code "GL_TEXTURE_2D")
                         ", "
                         (code "GL_TEXTURE_CUBE_MAP_POSITIVE_X")
                         ", "
                         (code "GL_TEXTURE_CUBE_MAP_NEGATIVE_X")
                         ", "
                         (code "GL_TEXTURE_CUBE_MAP_POSITIVE_Y")
                         ", "
                         (code "GL_TEXTURE_CUBE_MAP_NEGATIVE_Y")
                         ", "
                         (code "GL_TEXTURE_CUBE_MAP_POSITIVE_Z")
                         ", or "
                         (code "GL_TEXTURE_CUBE_MAP_NEGATIVE_Z")
                         ". "))
            (entry (% (heading (var "level")))
                   (para "
Specifies the level-of-detail number.
                    Level 0 is the base image level.
                    Level "
                         (var "n")
                         " is the "
                         (var "n")
                         "th mipmap reduction image. "))
            (entry (% (heading (var "xoffset")))
                   (para "
Specifies a texel offset in the x direction within the texture array. "))
            (entry (% (heading (var "yoffset")))
                   (para "
Specifies a texel offset in the y direction within the texture array. "))
            (entry (% (heading (var "width")))
                   (para "
Specifies the width of the texture subimage. "))
            (entry (% (heading (var "height")))
                   (para "
Specifies the height of the texture subimage. "))
            (entry (% (heading (var "format")))
                   (para "
Specifies the format of the pixel data.
                    The following symbolic values are accepted: "
                         (code "GL_COLOR_INDEX")
                         ", "
                         (code "GL_RED")
                         ", "
                         (code "GL_GREEN")
                         ", "
                         (code "GL_BLUE")
                         ", "
                         (code "GL_ALPHA")
                         ", "
                         (code "GL_RGB")
                         ", "
                         (code "GL_BGR")
                         ", "
                         (code "GL_RGBA")
                         ", "
                         (code "GL_BGRA")
                         ", "
                         (code "GL_LUMINANCE")
                         ", and "
                         (code "GL_LUMINANCE_ALPHA")
                         ". "))
            (entry (% (heading (var "type")))
                   (para "
Specifies the data type of the pixel data.
                    The following symbolic values are accepted: "
                         (code "GL_UNSIGNED_BYTE")
                         ", "
                         (code "GL_BYTE")
                         ", "
                         (code "GL_BITMAP")
                         ", "
                         (code "GL_UNSIGNED_SHORT")
                         ", "
                         (code "GL_SHORT")
                         ", "
                         (code "GL_UNSIGNED_INT")
                         ", "
                         (code "GL_INT")
                         ", "
                         (code "GL_FLOAT")
                         ", "
                         (code "GL_UNSIGNED_BYTE_3_3_2")
                         ", "
                         (code "GL_UNSIGNED_BYTE_2_3_3_REV")
                         ", "
                         (code "GL_UNSIGNED_SHORT_5_6_5")
                         ", "
                         (code "GL_UNSIGNED_SHORT_5_6_5_REV")
                         ", "
                         (code "GL_UNSIGNED_SHORT_4_4_4_4")
                         ", "
                         (code "GL_UNSIGNED_SHORT_4_4_4_4_REV")
                         ", "
                         (code "GL_UNSIGNED_SHORT_5_5_5_1")
                         ", "
                         (code "GL_UNSIGNED_SHORT_1_5_5_5_REV")
                         ", "
                         (code "GL_UNSIGNED_INT_8_8_8_8")
                         ", "
                         (code "GL_UNSIGNED_INT_8_8_8_8_REV")
                         ", "
                         (code "GL_UNSIGNED_INT_10_10_10_2")
                         ", and "
                         (code "GL_UNSIGNED_INT_2_10_10_10_REV")
                         ". "))
            (entry (% (heading (var "data")))
                   (para "
Specifies a pointer to the image data in memory. ")))
     (heading "Description")
     (para "
Texturing maps a portion of a specified texture image
            onto each graphical primitive for which texturing is enabled.
            To enable and disable two-dimensional texturing, call "
           (code "glEnable")
           "
and "
           (code "glDisable")
           " with argument "
           (code "GL_TEXTURE_2D")
           ". ")
     (para (code "glTexSubImage2D")
           " redefines a contiguous subregion of an existing two-dimensional
            texture image.
            The texels referenced by "
           (var "data")
           " replace the portion of the
            existing texture array with x indices "
           (var "xoffset")
           " and "
           (math (var "xoffset") "+" (var "width") "-" "1")
           ",
            inclusive,
            and y indices "
           (var "yoffset")
           " and "
           (math (var "yoffset") "+" (var "height") "-" "1")
           ",
            inclusive.
            This region may not include any texels outside the range of the
            texture array as it was originally specified.
            It is not an error to specify a subtexture with zero width or height, but
            such a specification has no effect. ")
     (para "
If a non-zero named buffer object is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target 
            (see "
           (code "glBindBuffer")
           ") while a texture image is
            specified, "
           (var "data")
           " is treated as a byte offset into the buffer object's data store. ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "target")
           " is not "
           (code "GL_TEXTURE_2D")
           ", "
           (code "GL_TEXTURE_CUBE_MAP_POSITIVE_X")
           ", "
           (code "GL_TEXTURE_CUBE_MAP_NEGATIVE_X")
           ", "
           (code "GL_TEXTURE_CUBE_MAP_POSITIVE_Y")
           ", "
           (code "GL_TEXTURE_CUBE_MAP_NEGATIVE_Y")
           ", "
           (code "GL_TEXTURE_CUBE_MAP_POSITIVE_Z")
           ", or "
           (code "GL_TEXTURE_CUBE_MAP_NEGATIVE_Z")
           ". ")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "format")
           " is not an accepted
            format constant. ")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "type")
           " is not a type constant. ")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "type")
           " is "
           (code "GL_BITMAP")
           " and "
           (var "format")
           " is not "
           (code "GL_COLOR_INDEX")
           ". ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "level")
           " is less than 0. ")
     (para (code "GL_INVALID_VALUE")
           " may be generated if "
           (var "level")
           " is greater
            than "
           (math (var "log") "_" "2")
           (var "max")
           ",
            where "
           (var "max")
           " is the returned value of "
           (code "GL_MAX_TEXTURE_SIZE")
           ". ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (math (var "xoffset") "<" "-" (var "b"))
           ", "
           (math "("
                 (var "xoffset")
                 "+"
                 (var "width")
                 ","
                 ")"
                 ">"
                 "("
                 (var "w")
                 "-"
                 (var "b")
                 ","
                 ")")
           ", "
           (math (var "yoffset") "<" "-" (var "b"))
           ",
            or "
           (math "("
                 (var "yoffset")
                 "+"
                 (var "height")
                 ","
                 ")"
                 ">"
                 "("
                 (var "h")
                 "-"
                 (var "b")
                 ","
                 ")")
           ",
            where "
           (math (var "w"))
           "
is the "
           (code "GL_TEXTURE_WIDTH")
           ", "
           (math (var "h"))
           "
is the "
           (code "GL_TEXTURE_HEIGHT")
           ", and "
           (math (var "b"))
           "
is the border width
            of the texture image being modified.
            Note that "
           (math (var "w"))
           "
and "
           (math (var "h"))
           "
include twice the border width. ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "width")
           " or "
           (var "height")
           " is less than 0. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if the texture array has not
            been defined by a previous "
           (code "glTexImage2D")
           " operation. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (var "type")
           " is one of "
           (code "GL_UNSIGNED_BYTE_3_3_2")
           ", "
           (code "GL_UNSIGNED_BYTE_2_3_3_REV")
           ", "
           (code "GL_UNSIGNED_SHORT_5_6_5")
           ", or "
           (code "GL_UNSIGNED_SHORT_5_6_5_REV")
           "
and "
           (var "format")
           " is not "
           (code "GL_RGB")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (var "type")
           " is one of "
           (code "GL_UNSIGNED_SHORT_4_4_4_4")
           ", "
           (code "GL_UNSIGNED_SHORT_4_4_4_4_REV")
           ", "
           (code "GL_UNSIGNED_SHORT_5_5_5_1")
           ", "
           (code "GL_UNSIGNED_SHORT_1_5_5_5_REV")
           ", "
           (code "GL_UNSIGNED_INT_8_8_8_8")
           ", "
           (code "GL_UNSIGNED_INT_8_8_8_8_REV")
           ", "
           (code "GL_UNSIGNED_INT_10_10_10_2")
           ", or "
           (code "GL_UNSIGNED_INT_2_10_10_10_REV")
           "
and "
           (var "format")
           " is neither "
           (code "GL_RGBA")
           " nor "
           (code "GL_BGRA")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target and the buffer object's data store is currently mapped. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target and the data would be unpacked from the buffer 
            object such that the memory reads required would exceed the data store size. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target and "
           (var "data")
           " is not evenly divisible 
            into the number of bytes needed to store in memory a datum indicated by "
           (var "type")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glTexSubImage2D")
           " is executed
            between the execution of "
           (code "glBegin")
           " and the corresponding
            execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glTexSubImage3D
  "glTexSubImage3D"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glTexSubImage3D"))
      (paramdef "GLenum " (parameter "target"))
      (paramdef "GLint " (parameter "level"))
      (paramdef "GLint " (parameter "xoffset"))
      (paramdef "GLint " (parameter "yoffset"))
      (paramdef "GLint " (parameter "zoffset"))
      (paramdef "GLsizei " (parameter "width"))
      (paramdef "GLsizei " (parameter "height"))
      (paramdef "GLsizei " (parameter "depth"))
      (paramdef "GLenum " (parameter "format"))
      (paramdef "GLenum " (parameter "type"))
      (paramdef "const GLvoid * " (parameter "data"))))
  '(*fragment*
     (heading
       "specify a three-dimensional texture subimage")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "target")))
                   (para "
Specifies the target texture.
                    Must be "
                         (code "GL_TEXTURE_3D")
                         ". "))
            (entry (% (heading (var "level")))
                   (para "
Specifies the level-of-detail number.
                    Level 0 is the base image level.
                    Level "
                         (var "n")
                         " is the "
                         (var "n")
                         "th mipmap reduction image. "))
            (entry (% (heading (var "xoffset")))
                   (para "
Specifies a texel offset in the x direction within the texture array. "))
            (entry (% (heading (var "yoffset")))
                   (para "
Specifies a texel offset in the y direction within the texture array. "))
            (entry (% (heading (var "zoffset")))
                   (para "
Specifies a texel offset in the z direction within the texture array. "))
            (entry (% (heading (var "width")))
                   (para "
Specifies the width of the texture subimage. "))
            (entry (% (heading (var "height")))
                   (para "
Specifies the height of the texture subimage. "))
            (entry (% (heading (var "depth")))
                   (para "
Specifies the depth of the texture subimage. "))
            (entry (% (heading (var "format")))
                   (para "
Specifies the format of the pixel data.
                    The following symbolic values are accepted: "
                         (code "GL_COLOR_INDEX")
                         ", "
                         (code "GL_RED")
                         ", "
                         (code "GL_GREEN")
                         ", "
                         (code "GL_BLUE")
                         ", "
                         (code "GL_ALPHA")
                         ", "
                         (code "GL_RGB")
                         ", "
                         (code "GL_BGR")
                         ", "
                         (code "GL_RGBA")
                         ", "
                         (code "GL_BGRA")
                         ", "
                         (code "GL_LUMINANCE")
                         ", and "
                         (code "GL_LUMINANCE_ALPHA")
                         ". "))
            (entry (% (heading (var "type")))
                   (para "
Specifies the data type of the pixel data.
                    The following symbolic values are accepted: "
                         (code "GL_UNSIGNED_BYTE")
                         ", "
                         (code "GL_BYTE")
                         ", "
                         (code "GL_BITMAP")
                         ", "
                         (code "GL_UNSIGNED_SHORT")
                         ", "
                         (code "GL_SHORT")
                         ", "
                         (code "GL_UNSIGNED_INT")
                         ", "
                         (code "GL_INT")
                         ", "
                         (code "GL_FLOAT")
                         ", "
                         (code "GL_UNSIGNED_BYTE_3_3_2")
                         ", "
                         (code "GL_UNSIGNED_BYTE_2_3_3_REV")
                         ", "
                         (code "GL_UNSIGNED_SHORT_5_6_5")
                         ", "
                         (code "GL_UNSIGNED_SHORT_5_6_5_REV")
                         ", "
                         (code "GL_UNSIGNED_SHORT_4_4_4_4")
                         ", "
                         (code "GL_UNSIGNED_SHORT_4_4_4_4_REV")
                         ", "
                         (code "GL_UNSIGNED_SHORT_5_5_5_1")
                         ", "
                         (code "GL_UNSIGNED_SHORT_1_5_5_5_REV")
                         ", "
                         (code "GL_UNSIGNED_INT_8_8_8_8")
                         ", "
                         (code "GL_UNSIGNED_INT_8_8_8_8_REV")
                         ", "
                         (code "GL_UNSIGNED_INT_10_10_10_2")
                         ", and "
                         (code "GL_UNSIGNED_INT_2_10_10_10_REV")
                         ". "))
            (entry (% (heading (var "data")))
                   (para "
Specifies a pointer to the image data in memory. ")))
     (heading "Description")
     (para "
Texturing maps a portion of a specified texture image
            onto each graphical primitive for which texturing is enabled.
            To enable and disable three-dimensional texturing, call "
           (code "glEnable")
           "
and "
           (code "glDisable")
           " with argument "
           (code "GL_TEXTURE_3D")
           ". ")
     (para (code "glTexSubImage3D")
           " redefines a contiguous subregion of an existing three-dimensional
            texture image.
            The texels referenced by "
           (var "data")
           " replace the portion of the
            existing texture array with x indices "
           (var "xoffset")
           " and "
           (math (var "xoffset") "+" (var "width") "-" "1")
           ",
            inclusive,
            y indices "
           (var "yoffset")
           " and "
           (math (var "yoffset") "+" (var "height") "-" "1")
           ",
            inclusive,
            and z indices "
           (var "zoffset")
           " and "
           (math (var "zoffset") "+" (var "depth") "-" "1")
           ",
            inclusive.
            This region may not include any texels outside the range of the
            texture array as it was originally specified.
            It is not an error to specify a subtexture with zero width, height, or
            depth but such a specification has no effect. ")
     (para "
If a non-zero named buffer object is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target 
            (see "
           (code "glBindBuffer")
           ") while a texture image is
            specified, "
           (var "data")
           " is treated as a byte offset into the buffer object's data store. ")
     (heading "Errors")
     (para (code "GL_INVALID_ENUM")
           " is generated if /"
           (var "target")
           " is not "
           (code "GL_TEXTURE_3D")
           ". ")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "format")
           " is not an accepted
            format constant. ")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "type")
           " is not a type constant. ")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "type")
           " is "
           (code "GL_BITMAP")
           " and "
           (var "format")
           " is not "
           (code "GL_COLOR_INDEX")
           ". ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "level")
           " is less than 0. ")
     (para (code "GL_INVALID_VALUE")
           " may be generated if "
           (var "level")
           " is greater
            than "
           (math (var "log") "_" "2")
           (var "max")
           ",
            where "
           (var "max")
           " is the returned value of "
           (code "GL_MAX_TEXTURE_SIZE")
           ". ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (math (var "xoffset") "<" "-" (var "b"))
           ", "
           (math "("
                 (var "xoffset")
                 "+"
                 (var "width")
                 ","
                 ")"
                 ">"
                 "("
                 (var "w")
                 "-"
                 (var "b")
                 ","
                 ")")
           ", "
           (math (var "yoffset") "<" "-" (var "b"))
           ",
            or "
           (math "("
                 (var "yoffset")
                 "+"
                 (var "height")
                 ","
                 ")"
                 ">"
                 "("
                 (var "h")
                 "-"
                 (var "b")
                 ","
                 ")")
           ",
            or "
           (math (var "zoffset") "<" "-" (var "b"))
           ",
            or "
           (math "("
                 (var "zoffset")
                 "+"
                 (var "depth")
                 ","
                 ")"
                 ">"
                 "("
                 (var "d")
                 "-"
                 (var "b")
                 ","
                 ")")
           ",
            where "
           (math (var "w"))
           "
is the "
           (code "GL_TEXTURE_WIDTH")
           ", "
           (math (var "h"))
           "
is the "
           (code "GL_TEXTURE_HEIGHT")
           ", "
           (math (var "d"))
           "
is the "
           (code "GL_TEXTURE_DEPTH")
           "
and "
           (math (var "b"))
           "
is the border width of the texture image being modified.
            Note that "
           (math (var "w"))
           ", "
           (math (var "h"))
           ",
            and "
           (math (var "d"))
           "
include twice the border width. ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "width")
           ", "
           (var "height")
           ", or "
           (var "depth")
           "
is less than 0. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if the texture array has not
            been defined by a previous "
           (code "glTexImage3D")
           " operation. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (var "type")
           " is one of "
           (code "GL_UNSIGNED_BYTE_3_3_2")
           ", "
           (code "GL_UNSIGNED_BYTE_2_3_3_REV")
           ", "
           (code "GL_UNSIGNED_SHORT_5_6_5")
           ", or "
           (code "GL_UNSIGNED_SHORT_5_6_5_REV")
           "
and "
           (var "format")
           " is not "
           (code "GL_RGB")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (var "type")
           " is one of "
           (code "GL_UNSIGNED_SHORT_4_4_4_4")
           ", "
           (code "GL_UNSIGNED_SHORT_4_4_4_4_REV")
           ", "
           (code "GL_UNSIGNED_SHORT_5_5_5_1")
           ", "
           (code "GL_UNSIGNED_SHORT_1_5_5_5_REV")
           ", "
           (code "GL_UNSIGNED_INT_8_8_8_8")
           ", "
           (code "GL_UNSIGNED_INT_8_8_8_8_REV")
           ", "
           (code "GL_UNSIGNED_INT_10_10_10_2")
           ", or "
           (code "GL_UNSIGNED_INT_2_10_10_10_REV")
           "
and "
           (var "format")
           " is neither "
           (code "GL_RGBA")
           " nor "
           (code "GL_BGRA")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target and the buffer object's data store is currently mapped. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target and the data would be unpacked from the buffer 
            object such that the memory reads required would exceed the data store size. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a non-zero buffer object name is bound to the "
           (code "GL_PIXEL_UNPACK_BUFFER")
           " target and "
           (var "data")
           " is not evenly divisible 
            into the number of bytes needed to store in memory a datum indicated by "
           (var "type")
           ". ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glTexSubImage3D")
           " is executed
            between the execution of "
           (code "glBegin")
           " and the corresponding
            execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glTranslate
  "glTranslate"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glTranslated"))
      (paramdef "GLdouble " (parameter "x"))
      (paramdef "GLdouble " (parameter "y"))
      (paramdef "GLdouble " (parameter "z"))))
  '(*fragment*
     (heading
       "multiply the current matrix by a translation matrix")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "x")))
                   (itemx (var "y"))
                   (itemx (var "z"))
                   (para "
Specify the "
                         (var "x")
                         ", "
                         (var "y")
                         ", and "
                         (var "z")
                         " coordinates of a translation vector. ")))
     (heading "Description")
     (para (code "glTranslate")
           " produces a translation by "
           (math "(" (var "x") "," (var "y") (var "z") ")")
           ".
            The current matrix
            (see "
           (code "glMatrixMode")
           ")
            is multiplied by this translation matrix,
            with the product replacing the current matrix, as if "
           (code "glMultMatrix")
           " were called with the following matrix
            for its argument: ")
     (para (math "("
                 "("
                 "1"
                 " "
                 "0"
                 " "
                 "0"
                 " "
                 (var "x")
                 ")"
                 ", "
                 "("
                 "0"
                 " "
                 "1"
                 " "
                 "0"
                 " "
                 (var "y")
                 ")"
                 ", "
                 "("
                 "0"
                 " "
                 "0"
                 " "
                 "1"
                 " "
                 (var "z")
                 ")"
                 ", "
                 "("
                 "0"
                 " "
                 "0"
                 " "
                 "0"
                 " "
                 "1"
                 ")"
                 ","
                 ")"))
     (para)
     (para "
If the matrix mode is either "
           (code "GL_MODELVIEW")
           " or "
           (code "GL_PROJECTION")
           ",
            all objects drawn after a call to "
           (code "glTranslate")
           " are translated. ")
     (para "
Use "
           (code "glPushMatrix")
           " and "
           (code "glPopMatrix")
           " to save and restore
            the untranslated coordinate system. ")
     (heading "Errors")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glTranslate")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glUniform1f
  "glUniform1f"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glUniform1f"))
      (paramdef "GLint " (parameter "location"))
      (paramdef "GLfloat " (parameter "v0")))
    (funcprototype
      (funcdef "void " (function "glUniform2f"))
      (paramdef "GLint " (parameter "location"))
      (paramdef "GLfloat " (parameter "v0"))
      (paramdef "GLfloat " (parameter "v1")))
    (funcprototype
      (funcdef "void " (function "glUniform3f"))
      (paramdef "GLint " (parameter "location"))
      (paramdef "GLfloat " (parameter "v0"))
      (paramdef "GLfloat " (parameter "v1"))
      (paramdef "GLfloat " (parameter "v2")))
    (funcprototype
      (funcdef "void " (function "glUniform4f"))
      (paramdef "GLint " (parameter "location"))
      (paramdef "GLfloat " (parameter "v0"))
      (paramdef "GLfloat " (parameter "v1"))
      (paramdef "GLfloat " (parameter "v2"))
      (paramdef "GLfloat " (parameter "v3")))
    (funcprototype
      (funcdef "void " (function "glUniform1i"))
      (paramdef "GLint " (parameter "location"))
      (paramdef "GLint " (parameter "v0")))
    (funcprototype
      (funcdef "void " (function "glUniform2i"))
      (paramdef "GLint " (parameter "location"))
      (paramdef "GLint " (parameter "v0"))
      (paramdef "GLint " (parameter "v1")))
    (funcprototype
      (funcdef "void " (function "glUniform3i"))
      (paramdef "GLint " (parameter "location"))
      (paramdef "GLint " (parameter "v0"))
      (paramdef "GLint " (parameter "v1"))
      (paramdef "GLint " (parameter "v2")))
    (funcprototype
      (funcdef "void " (function "glUniform4i"))
      (paramdef "GLint " (parameter "location"))
      (paramdef "GLint " (parameter "v0"))
      (paramdef "GLint " (parameter "v1"))
      (paramdef "GLint " (parameter "v2"))
      (paramdef "GLint " (parameter "v3"))))
  '(*fragment*
     (heading
       "Specify the value of a uniform variable for the current program object")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "location")))
                   (para "Specifies the location of the uniform variable
\t\t    to be modified."))
            (entry (% (heading
                        (var "v0")
                        ", "
                        (var "v1")
                        ", "
                        (var "v2")
                        ", "
                        (var "v3")))
                   (para "Specifies the new values to be used for the
\t\t    specified uniform variable.")))
     (heading "Description")
     (para (code "glUniform")
           " modifies the value of a
\tuniform variable or a uniform variable array. The location of
\tthe uniform variable to be modified is specified by\t"
           (var "location")
           ", which should be a value
\treturned by\t"
           (code "glGetUniformLocation")
           ".\t"
           (code "glUniform")
           " operates on the program object
\tthat was made part of current state by calling\t"
           (code "glUseProgram")
           ".")
     (para "The commands "
           (code "glUniform{1|2|3|4}{f|i}")
           "
are used to change the value of the uniform variable specified
\tby "
           (var "location")
           " using the values passed as
\targuments. The number specified in the command should match the
\tnumber of components in the data type of the specified uniform
\tvariable (e.g., "
           (code "1")
           " for float, int, bool;\t"
           (code "2")
           " for vec2, ivec2, bvec2, etc.). The suffix\t"
           (code "f")
           " indicates that floating-point values are
\tbeing passed; the suffix "
           (code "i")
           " indicates that
\tinteger values are being passed, and this type should also match
\tthe data type of the specified uniform variable. The\t"
           (code "i")
           " variants of this function should be used
\tto provide values for uniform variables defined as int, ivec2,
\tivec3, ivec4, or arrays of these. The "
           (code "f")
           "
variants should be used to provide values for uniform variables
\tof type float, vec2, vec3, vec4, or arrays of these. Either the\t"
           (code "i")
           " or the "
           (code "f")
           " variants
\tmay be used to provide values for uniform variables of type
\tbool, bvec2, bvec3, bvec4, or arrays of these. The uniform
\tvariable will be set to false if the input value is 0 or 0.0f,
\tand it will be set to true otherwise.")
     (para "All active uniform variables defined in a program object
\tare initialized to 0 when the program object is linked
\tsuccessfully. They retain the values assigned to them by a call
\tto "
           (code "glUniform ")
           " until the next successful
\tlink operation occurs on the program object, when they are once
\tagain initialized to 0.")
     (para "The commands "
           (code "glUniform{1|2|3|4}{f|i}v")
           "
can be used to modify a single uniform variable or a uniform
\tvariable array. These commands pass a count and a pointer to the
\tvalues to be loaded into a uniform variable or a uniform
\tvariable array. A count of 1 should be used if modifying the
\tvalue of a single uniform variable, and a count of 1 or greater
\tcan be used to modify an entire array or part of an array. When
\tloading "
           (var "n")
           " elements starting at an arbitrary
\tposition "
           (var "m")
           " in a uniform variable array,
\telements "
           (var "m")
           " + "
           (var "n")
           " - 1 in
\tthe array will be replaced with the new values. If\t"
           (var "m")
           " + "
           (var "n")
           " - 1 is
\tlarger than the size of the uniform variable array, values for
\tall array elements beyond the end of the array will be ignored.
\tThe number specified in the name of the command indicates the
\tnumber of components for each element in\t"
           (var "value")
           ", and it should match the number of
\tcomponents in the data type of the specified uniform variable
\t(e.g., "
           (code "1")
           " for float, int, bool;\t"
           (code "2")
           " for vec2, ivec2, bvec2, etc.). The data
\ttype specified in the name of the command must match the data
\ttype for the specified uniform variable as described previously
\tfor "
           (code "glUniform{1|2|3|4}{f|i}")
           ".")
     (para "For uniform variable arrays, each element of the array is
\tconsidered to be of the type indicated in the name of the
\tcommand (e.g., "
           (code "glUniform3f")
           " or\t"
           (code "glUniform3fv")
           " can be used to load a uniform
\tvariable array of type vec3). The number of elements of the
\tuniform variable array to be modified is specified by\t"
           (var "count"))
     (para "The commands\t"
           (code "glUniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv")
           " are used to modify a matrix or an array of matrices. The numbers in the
\tcommand name are interpreted as the dimensionality of the matrix.
\tThe number "
           (code "2")
           " indicates a 2 × 2 matrix
\t(i.e., 4 values), the number "
           (code "3")
           " indicates a
\t3 × 3 matrix (i.e., 9 values), and the number\t"
           (code "4")
           " indicates a 4 × 4 matrix (i.e., 16
\tvalues). Non-square matrix dimensionality is explicit, with the first
        number representing the number of columns and the second number
        representing the number of rows.  For example, "
           (code "2x4")
           " indicates a 2 × 4 matrix with 2 columns
        and 4 rows (i.e., 8 values).
        If "
           (var "transpose")
           " is\t"
           (code "GL_FALSE")
           ", each matrix is assumed to be
\tsupplied in column major order. If\t"
           (var "transpose")
           " is\t"
           (code "GL_TRUE")
           ", each matrix is assumed to be
\tsupplied in row major order. The "
           (var "count")
           "
argument indicates the number of matrices to be passed. A count
\tof 1 should be used if modifying the value of a single matrix,
\tand a count greater than 1 can be used to modify an array of
\tmatrices.")
     (heading "Errors")
     (para (code "GL_INVALID_OPERATION")
           " is generated if there
\tis no current program object.")
     (para (code "GL_INVALID_OPERATION")
           " is generated if the
\tsize of the uniform variable declared in the shader does not
\tmatch the size indicated by the "
           (code "glUniform")
           "
command.")
     (para (code "GL_INVALID_OPERATION")
           " is generated if one of
\tthe integer variants of this function is used to load a uniform
\tvariable of type float, vec2, vec3, vec4, or an array of these,
\tor if one of the floating-point variants of this function is
\tused to load a uniform variable of type int, ivec2, ivec3, or
\tivec4, or an array of these.")
     (para (code "GL_INVALID_OPERATION")
           " is generated if\t"
           (var "location")
           " is an invalid uniform location
\tfor the current program object and\t"
           (var "location")
           " is not equal to -1.")
     (para (code "GL_INVALID_VALUE")
           " is generated if\t"
           (var "count")
           " is less than 0.")
     (para (code "GL_INVALID_OPERATION")
           " is generated if\t"
           (var "count")
           " is greater than 1 and the indicated
\tuniform variable is not an array variable.")
     (para (code "GL_INVALID_OPERATION")
           " is generated if a
\tsampler is loaded using a command other than\t"
           (code "glUniform1i")
           " and\t"
           (code "glUniform1iv")
           ".")
     (para (code "GL_INVALID_OPERATION")
           " is generated if\t"
           (code "glUniform")
           " is executed between the execution
\tof\t"
           (code "glBegin")
           "
and the corresponding execution of\t"
           (code "glEnd")
           ".")))

(define-gl-procedure
  glUseProgram
  "glUseProgram"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glUseProgram"))
      (paramdef "GLuint " (parameter "program"))))
  '(*fragment*
     (heading
       "Installs a program object as part of current rendering state")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "program")))
                   (para "Specifies the handle of the program object
\t\t    whose executables are to be used as part of current
\t\t    rendering state.")))
     (heading "Description")
     (para (code "glUseProgram")
           " installs the program
\tobject specified by "
           (var "program")
           " as part of
\tcurrent rendering state. One or more executables are created in
\ta program object by successfully attaching shader objects to it
\twith\t"
           (code "glAttachShader")
           ",
\tsuccessfully compiling the shader objects with\t"
           (code "glCompileShader")
           ",
\tand successfully linking the program object with\t"
           (code "glLinkProgram")
           ".\t")
     (para "A program object will contain an executable that will run
\ton the vertex processor if it contains one or more shader
\tobjects of type "
           (code "GL_VERTEX_SHADER")
           " that have
\tbeen successfully compiled and linked. Similarly, a program
\tobject will contain an executable that will run on the fragment
\tprocessor if it contains one or more shader objects of type\t"
           (code "GL_FRAGMENT_SHADER")
           " that have been
\tsuccessfully compiled and linked.")
     (para "Successfully installing an executable on a programmable
\tprocessor will cause the corresponding fixed functionality of
\tOpenGL to be disabled. Specifically, if an executable is
\tinstalled on the vertex processor, the OpenGL fixed
\tfunctionality will be disabled as follows.")
     (itemize
       (item (para "The modelview matrix is not applied to vertex
\t\tcoordinates."))
       (item (para "The projection matrix is not applied to vertex
\t\tcoordinates."))
       (item (para "The texture matrices are not applied to texture
\t\tcoordinates."))
       (item (para "Normals are not transformed to eye
\t\tcoordinates."))
       (item (para "Normals are not rescaled or normalized."))
       (item (para "Normalization of\t"
                   (code "GL_AUTO_NORMAL")
                   " evaluated normals is
\t\tnot performed."))
       (item (para "Texture coordinates are not generated
\t\tautomatically."))
       (item (para "Per-vertex lighting is not performed."))
       (item (para "Color material computations are not
\t\tperformed."))
       (item (para "Color index lighting is not performed."))
       (item (para "This list also applies when setting the current
\t\traster position.")))
     (para "The executable that is installed on the vertex processor
\tis expected to implement any or all of the desired functionality
\tfrom the preceding list. Similarly, if an executable is
\tinstalled on the fragment processor, the OpenGL fixed
\tfunctionality will be disabled as follows.")
     (itemize
       (item (para "Texture environment and texture functions are not
\t\tapplied."))
       (item (para "Texture application is not applied."))
       (item (para "Color sum is not applied."))
       (item (para "Fog is not applied.")))
     (para "Again, the fragment shader that is installed is expected
\tto implement any or all of the desired functionality from the
\tpreceding list.")
     (para "While a program object is in use, applications are free to
\tmodify attached shader objects, compile attached shader objects,
\tattach additional shader objects, and detach or delete shader
\tobjects. None of these operations will affect the executables
\tthat are part of the current state. However, relinking the
\tprogram object that is currently in use will install the program
\tobject as part of the current rendering state if the link
\toperation was successful (see\t"
           (code "glLinkProgram")
           "
). If the program object currently in use is relinked
\tunsuccessfully, its link status will be set to\t"
           (code "GL_FALSE")
           ", but the executables and
\tassociated state will remain part of the current state until a
\tsubsequent call to "
           (code "glUseProgram")
           " removes it
\tfrom use. After it is removed from use, it cannot be made part
\tof current state until it has been successfully relinked.")
     (para "If "
           (var "program")
           " contains shader objects
\tof type "
           (code "GL_VERTEX_SHADER")
           " but it does not
\tcontain shader objects of type\t"
           (code "GL_FRAGMENT_SHADER")
           ", an executable will be
\tinstalled on the vertex processor, but fixed functionality will
\tbe used for fragment processing. Similarly, if\t"
           (var "program")
           " contains shader objects of type\t"
           (code "GL_FRAGMENT_SHADER")
           " but it does not contain
\tshader objects of type "
           (code "GL_VERTEX_SHADER")
           ", an
\texecutable will be installed on the fragment processor, but
\tfixed functionality will be used for vertex processing. If\t"
           (var "program")
           " is 0, the programmable processors
\twill be disabled, and fixed functionality will be used for both
\tvertex and fragment processing.")
     (heading "Errors")
     (para (code "GL_INVALID_VALUE")
           " is generated if\t"
           (var "program")
           " is neither 0 nor a value
\tgenerated by OpenGL.")
     (para (code "GL_INVALID_OPERATION")
           " is generated if\t"
           (var "program")
           " is not a program object.")
     (para (code "GL_INVALID_OPERATION")
           " is generated if\t"
           (var "program")
           " could not be made part of current
\tstate.")
     (para (code "GL_INVALID_OPERATION")
           " is generated if\t"
           (code "glUseProgram")
           " is executed between the
\texecution of\t"
           (code "glBegin")
           "
and the corresponding execution of\t"
           (code "glEnd")
           ".")))

(define-gl-procedure
  glValidateProgram
  "glValidateProgram"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glValidateProgram"))
      (paramdef "GLuint " (parameter "program"))))
  '(*fragment*
     (heading "Validates a program object")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "program")))
                   (para "Specifies the handle of the program object to
\t\t    be validated.")))
     (heading "Description")
     (para (code "glValidateProgram")
           " checks to see
\twhether the executables contained in\t"
           (var "program")
           " can execute given the current
\tOpenGL state. The information generated by the validation
\tprocess will be stored in "
           (var "program")
           "'s
\tinformation log. The validation information may consist of an
\tempty string, or it may be a string containing information about
\thow the current program object interacts with the rest of
\tcurrent OpenGL state. This provides a way for OpenGL
\timplementers to convey more information about why the current
\tprogram is inefficient, suboptimal, failing to execute, and so
\ton.")
     (para "The status of the validation operation will be stored as
\tpart of the program object's state. This value will be set to\t"
           (code "GL_TRUE")
           " if the validation succeeded, and\t"
           (code "GL_FALSE")
           " otherwise. It can be queried by
\tcalling\t"
           (code "glGetProgram")
           "
with arguments "
           (var "program")
           " and\t"
           (code "GL_VALIDATE_STATUS")
           ". If validation is
\tsuccessful, "
           (var "program")
           " is guaranteed to
\texecute given the current state. Otherwise,\t"
           (var "program")
           " is guaranteed to not execute.")
     (para "This function is typically useful only during application
\tdevelopment. The informational string stored in the information
\tlog is completely implementation dependent; therefore, an
\tapplication should not expect different OpenGL implementations
\tto produce identical information strings.")
     (heading "Errors")
     (para (code "GL_INVALID_VALUE")
           " is generated if\t"
           (var "program")
           " is not a value generated by
\tOpenGL.")
     (para (code "GL_INVALID_OPERATION")
           " is generated if\t"
           (var "program")
           " is not a program object.")
     (para (code "GL_INVALID_OPERATION")
           " is generated if\t"
           (code "glValidateProgram")
           " is executed between the
\texecution of\t"
           (code "glBegin")
           "
and the corresponding execution of\t"
           (code "glEnd")
           ".")))

(define-gl-procedure
  glVertexAttribPointer
  "glVertexAttribPointer"
  (funcsynopsis
    (funcprototype
      (funcdef
        "void "
        (function "glVertexAttribPointer"))
      (paramdef "GLuint " (parameter "index"))
      (paramdef "GLint " (parameter "size"))
      (paramdef "GLenum " (parameter "type"))
      (paramdef "GLboolean " (parameter "normalized"))
      (paramdef "GLsizei " (parameter "stride"))
      (paramdef
        "const GLvoid * "
        (parameter "pointer"))))
  '(*fragment*
     (heading
       "define an array of generic vertex attribute data")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "index")))
                   (para "Specifies the index of the generic vertex
\t\t    attribute to be modified."))
            (entry (% (heading (var "size")))
                   (para "Specifies the number of components per
\t\t    generic vertex attribute. Must
\t\t    be 1, 2, 3, or 4. The initial value is 4."))
            (entry (% (heading (var "type")))
                   (para "Specifies the data type of each component in
\t\t    the array. Symbolic constants "
                         (code "GL_BYTE")
                         ", "
                         (code "GL_UNSIGNED_BYTE")
                         ", "
                         (code "GL_SHORT")
                         ", "
                         (code "GL_UNSIGNED_SHORT")
                         ", "
                         (code "GL_INT")
                         ", "
                         (code "GL_UNSIGNED_INT")
                         ", "
                         (code "GL_FLOAT")
                         ", or "
                         (code "GL_DOUBLE")
                         " are
\t\t    accepted. The initial value is "
                         (code "GL_FLOAT")
                         "."))
            (entry (% (heading (var "normalized")))
                   (para "Specifies whether fixed-point data values
\t\t    should be normalized ("
                         (code "GL_TRUE")
                         ")
\t\t    or converted directly as fixed-point values
\t\t    ("
                         (code "GL_FALSE")
                         ") when they are
\t\t    accessed."))
            (entry (% (heading (var "stride")))
                   (para "Specifies the byte offset between consecutive
\t\t    generic vertex attributes. If "
                         (var "stride")
                         "
is 0, the generic vertex attributes are
\t\t    understood to be tightly packed in the
\t\t    array. The initial value is 0."))
            (entry (% (heading (var "pointer")))
                   (para "Specifies a pointer to the first component of
\t\t    the first generic vertex attribute in the array. The initial value is 0.")))
     (heading "Description")
     (para (code "glVertexAttribPointer")
           " specifies the
\tlocation and data format of the array of generic vertex attributes at index "
           (var "index")
           "
to use when rendering. "
           (var "size")
           "
specifies the number of components per attribute and must be 1,
\t2, 3, or 4. "
           (var "type")
           " specifies the data type
\tof each component, and "
           (var "stride")
           " specifies
\tthe byte stride from one attribute to the next, allowing vertices and
\tattributes to be packed into a single array or
\tstored in separate arrays. 
        If set to "
           (code "GL_TRUE")
           ",\t"
           (var "normalized")
           " indicates that values stored
\tin an integer format are to be mapped to the range [-1,1] (for
\tsigned values) or [0,1] (for unsigned values) when they are
\taccessed and converted to floating point. Otherwise, values will
\tbe converted to floats directly without normalization.")
     (para "If a non-zero named buffer object is bound to the "
           (code "GL_ARRAY_BUFFER")
           " target 
        (see "
           (code "glBindBuffer")
           ") while a generic vertex attribute array is
        specified, "
           (var "pointer")
           " is treated as a byte offset into the buffer object's data store.
        Also, the buffer object binding ("
           (code "GL_ARRAY_BUFFER_BINDING")
           ") is saved as generic vertex attribute array
        client-side state ("
           (code "GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING")
           ") for index "
           (var "index")
           ".")
     (para "When a generic vertex attribute array is specified,\t"
           (var "size")
           ", "
           (var "type")
           ",\t"
           (var "normalized")
           ",\t"
           (var "stride")
           ", and\t"
           (var "pointer")
           " are saved as client-side
\tstate, in addition to the current vertex array buffer object binding.")
     (para "To enable and disable a generic vertex attribute array,
\tcall\t"
           (code "glEnableVertexAttribArray")
           "
and\t"
           (code "glDisableVertexAttribArray")
           "
with "
           (var "index")
           ". If enabled, the generic
\tvertex attribute array is used when "
           (code "glArrayElement")
           ", "
           (code "glDrawArrays")
           ", "
           (code "glMultiDrawArrays")
           ", "
           (code "glDrawElements")
           ", "
           (code "glMultiDrawElements")
           ", or "
           (code "glDrawRangeElements")
           "
is called.")
     (heading "Errors")
     (para (code "GL_INVALID_VALUE")
           " is generated if\t"
           (var "index")
           " is greater than or equal to\t"
           (code "GL_MAX_VERTEX_ATTRIBS")
           ".")
     (para (code "GL_INVALID_VALUE")
           " is generated if\t"
           (var "size")
           " is not 1, 2, 3, or 4.")
     (para (code "GL_INVALID_ENUM")
           " is generated if\t"
           (var "type")
           " is not an accepted value.")
     (para (code "GL_INVALID_VALUE")
           " is generated if\t"
           (var "stride")
           " is negative.")))

(define-gl-procedure
  glVertexAttrib
  "glVertexAttrib"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glVertexAttrib1f"))
      (paramdef "GLuint " (parameter "index"))
      (paramdef "GLfloat " (parameter "v0")))
    (funcprototype
      (funcdef "void " (function "glVertexAttrib1s"))
      (paramdef "GLuint " (parameter "index"))
      (paramdef "GLshort " (parameter "v0")))
    (funcprototype
      (funcdef "void " (function "glVertexAttrib1d"))
      (paramdef "GLuint " (parameter "index"))
      (paramdef "GLdouble " (parameter "v0")))
    (funcprototype
      (funcdef "void " (function "glVertexAttrib2f"))
      (paramdef "GLuint " (parameter "index"))
      (paramdef "GLfloat " (parameter "v0"))
      (paramdef "GLfloat " (parameter "v1")))
    (funcprototype
      (funcdef "void " (function "glVertexAttrib2s"))
      (paramdef "GLuint " (parameter "index"))
      (paramdef "GLshort " (parameter "v0"))
      (paramdef "GLshort " (parameter "v1")))
    (funcprototype
      (funcdef "void " (function "glVertexAttrib2d"))
      (paramdef "GLuint " (parameter "index"))
      (paramdef "GLdouble " (parameter "v0"))
      (paramdef "GLdouble " (parameter "v1")))
    (funcprototype
      (funcdef "void " (function "glVertexAttrib3f"))
      (paramdef "GLuint " (parameter "index"))
      (paramdef "GLfloat " (parameter "v0"))
      (paramdef "GLfloat " (parameter "v1"))
      (paramdef "GLfloat " (parameter "v2")))
    (funcprototype
      (funcdef "void " (function "glVertexAttrib3s"))
      (paramdef "GLuint " (parameter "index"))
      (paramdef "GLshort " (parameter "v0"))
      (paramdef "GLshort " (parameter "v1"))
      (paramdef "GLshort " (parameter "v2")))
    (funcprototype
      (funcdef "void " (function "glVertexAttrib3d"))
      (paramdef "GLuint " (parameter "index"))
      (paramdef "GLdouble " (parameter "v0"))
      (paramdef "GLdouble " (parameter "v1"))
      (paramdef "GLdouble " (parameter "v2")))
    (funcprototype
      (funcdef "void " (function "glVertexAttrib4f"))
      (paramdef "GLuint " (parameter "index"))
      (paramdef "GLfloat " (parameter "v0"))
      (paramdef "GLfloat " (parameter "v1"))
      (paramdef "GLfloat " (parameter "v2"))
      (paramdef "GLfloat " (parameter "v3")))
    (funcprototype
      (funcdef "void " (function "glVertexAttrib4s"))
      (paramdef "GLuint " (parameter "index"))
      (paramdef "GLshort " (parameter "v0"))
      (paramdef "GLshort " (parameter "v1"))
      (paramdef "GLshort " (parameter "v2"))
      (paramdef "GLshort " (parameter "v3")))
    (funcprototype
      (funcdef "void " (function "glVertexAttrib4d"))
      (paramdef "GLuint " (parameter "index"))
      (paramdef "GLdouble " (parameter "v0"))
      (paramdef "GLdouble " (parameter "v1"))
      (paramdef "GLdouble " (parameter "v2"))
      (paramdef "GLdouble " (parameter "v3")))
    (funcprototype
      (funcdef "void " (function "glVertexAttrib4Nub"))
      (paramdef "GLuint " (parameter "index"))
      (paramdef "GLubyte " (parameter "v0"))
      (paramdef "GLubyte " (parameter "v1"))
      (paramdef "GLubyte " (parameter "v2"))
      (paramdef "GLubyte " (parameter "v3"))))
  '(*fragment*
     (heading
       "Specifies the value of a generic vertex attribute")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "index")))
                   (para "Specifies the index of the generic vertex
\t\t    attribute to be modified."))
            (entry (% (heading
                        (var "v0")
                        ", "
                        (var "v1")
                        ", "
                        (var "v2")
                        ", "
                        (var "v3")))
                   (para "Specifies the new values to be used for the
\t\t    specified vertex attribute.")))
     (heading "Description")
     (para "OpenGL defines a number of standard vertex attributes that
\tapplications can modify with standard API entry points (color,
\tnormal, texture coordinates, etc.). The\t"
           (code "glVertexAttrib")
           " family of entry points
\tallows an application to pass generic vertex attributes in
\tnumbered locations.")
     (para "Generic attributes are defined as four-component values
\tthat are organized into an array. The first entry of this array
\tis numbered 0, and the size of the array is specified by the
\timplementation-dependent constant\t"
           (code "GL_MAX_VERTEX_ATTRIBS")
           ". Individual elements
\tof this array can be modified with a\t"
           (code "glVertexAttrib")
           " call that specifies the
\tindex of the element to be modified and a value for that
\telement.")
     (para "These commands can be used to specify one, two, three, or
\tall four components of the generic vertex attribute specified by\t"
           (var "index")
           ". A "
           (code "1")
           " in the
\tname of the command indicates that only one value is passed, and
\tit will be used to modify the first component of the generic
\tvertex attribute. The second and third components will be set to
\t0, and the fourth component will be set to 1. Similarly, a\t"
           (code "2")
           " in the name of the command indicates that
\tvalues are provided for the first two components, the third
\tcomponent will be set to 0, and the fourth component will be set
\tto 1. A "
           (code "3")
           " in the name of the command
\tindicates that values are provided for the first three
\tcomponents and the fourth component will be set to 1, whereas a\t"
           (code "4")
           " in the name indicates that values are
\tprovided for all four components.")
     (para "The letters "
           (code "s")
           ",\t"
           (code "f")
           ", "
           (code "i")
           ",\t"
           (code "d")
           ", "
           (code "ub")
           ",\t"
           (code "us")
           ", and "
           (code "ui")
           " indicate
\twhether the arguments are of type short, float, int, double,
\tunsigned byte, unsigned short, or unsigned int. When\t"
           (code "v")
           " is appended to the name, the commands can
\ttake a pointer to an array of such values. The commands
\tcontaining "
           (code "N")
           " indicate that the arguments
\twill be passed as fixed-point values that are scaled to a
\tnormalized range according to the component conversion rules
\tdefined by the OpenGL specification. Signed values are
\tunderstood to represent fixed-point values in the range [-1,1],
\tand unsigned values are understood to represent fixed-point
\tvalues in the range [0,1].")
     (para "OpenGL Shading Language attribute variables are allowed to
\tbe of type mat2, mat3, or mat4. Attributes of these types may be
\tloaded using the "
           (code "glVertexAttrib")
           " entry
\tpoints. Matrices must be loaded into successive generic
\tattribute slots in column major order, with one column of the
\tmatrix in each generic attribute slot.")
     (para "A user-defined attribute variable declared in a vertex
\tshader can be bound to a generic attribute index by calling\t"
           (code "glBindAttribLocation")
           ".
\tThis allows an application to use more descriptive variable
\tnames in a vertex shader. A subsequent change to the specified
\tgeneric vertex attribute will be immediately reflected as a
\tchange to the corresponding attribute variable in the vertex
\tshader.")
     (para "The binding between a generic vertex attribute index and a
\tuser-defined attribute variable in a vertex shader is part of
\tthe state of a program object, but the current value of the
\tgeneric vertex attribute is not. The value of each generic
\tvertex attribute is part of current state, just like standard
\tvertex attributes, and it is maintained even if a different
\tprogram object is used.")
     (para "An application may freely modify generic vertex attributes
\tthat are not bound to a named vertex shader attribute variable.
\tThese values are simply maintained as part of current state and
\twill not be accessed by the vertex shader. If a generic vertex
\tattribute bound to an attribute variable in a vertex shader is
\tnot updated while the vertex shader is executing, the vertex
\tshader will repeatedly use the current value for the generic
\tvertex attribute.")
     (para "The generic vertex attribute with index 0 is the same as
\tthe vertex position attribute previously defined by OpenGL. A\t"
           (code "glVertex2")
           ",\t"
           (code "glVertex3")
           ",
\tor\t"
           (code "glVertex4")
           "
command is completely equivalent to the corresponding\t"
           (code "glVertexAttrib")
           " command with an index
\targument of 0. A vertex shader can access generic vertex
\tattribute 0 by using the built-in attribute variable\t"
           (var "gl_Vertex")
           ". There are no current values
\tfor generic vertex attribute 0. This is the only generic vertex
\tattribute with this property; calls to set other standard vertex
\tattributes can be freely mixed with calls to set any of the
\tother generic vertex attributes.")
     (heading "Errors")
     (para (code "GL_INVALID_VALUE")
           " is generated if\t"
           (var "index")
           " is greater than or equal to\t"
           (code "GL_MAX_VERTEX_ATTRIBS")
           ".")))

(define-gl-procedure
  glVertexPointer
  "glVertexPointer"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glVertexPointer"))
      (paramdef "GLint " (parameter "size"))
      (paramdef "GLenum " (parameter "type"))
      (paramdef "GLsizei " (parameter "stride"))
      (paramdef
        "const GLvoid * "
        (parameter "pointer"))))
  '(*fragment*
     (heading "define an array of vertex data")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "size")))
                   (para "
Specifies the number of coordinates per vertex. Must be 2, 3, or
                    4. The initial value is 4. "))
            (entry (% (heading (var "type")))
                   (para "
Specifies the data type of each coordinate in the array.
                    Symbolic constants "
                         (code "GL_SHORT")
                         ", "
                         (code "GL_INT")
                         ", "
                         (code "GL_FLOAT")
                         ",
                    or "
                         (code "GL_DOUBLE")
                         "
are accepted. The initial value is "
                         (code "GL_FLOAT")
                         ". "))
            (entry (% (heading (var "stride")))
                   (para "
Specifies the byte offset between consecutive
                    vertices. If "
                         (var "stride")
                         " is 0, the vertices are understood to be tightly packed in
                    the array. The initial value
                    is 0. "))
            (entry (% (heading (var "pointer")))
                   (para "
Specifies a pointer to the first coordinate of the first vertex in the
                    array. The initial value is 0. ")))
     (heading "Description")
     (para (code "glVertexPointer")
           " specifies the location and data format of an array of vertex coordinates
            to use when rendering. "
           (var "size")
           " specifies the number of coordinates per vertex, and must be 2, 3, or 4. "
           (var "type")
           " specifies the data type of each coordinate, and "
           (var "stride")
           " specifies the byte stride from one
            vertex to the next, allowing vertices and attributes
            to be packed into a single array or stored in separate arrays.
            (Single-array storage may be more efficient on some implementations;
            see "
           (code "glInterleavedArrays")
           ".) ")
     (para "
If a non-zero named buffer object is bound to the "
           (code "GL_ARRAY_BUFFER")
           " target 
            (see "
           (code "glBindBuffer")
           ") while a vertex array is
            specified, "
           (var "pointer")
           " is treated as a byte offset into the buffer object's data store.
            Also, the buffer object binding ("
           (code "GL_ARRAY_BUFFER_BINDING")
           ") is saved as vertex array
            client-side state ("
           (code "GL_VERTEX_ARRAY_BUFFER_BINDING")
           "). ")
     (para "
When a vertex array is specified, "
           (var "size")
           ", "
           (var "type")
           ", "
           (var "stride")
           ", and "
           (var "pointer")
           " are saved as client-side
            state, in addition to the current vertex array buffer object binding. ")
     (para "
To enable and disable the vertex array, call "
           (code "glEnableClientState")
           " and "
           (code "glDisableClientState")
           " with the argument "
           (code "GL_VERTEX_ARRAY")
           ". If
            enabled, the vertex array is used when "
           (code "glArrayElement")
           ", "
           (code "glDrawArrays")
           ", "
           (code "glMultiDrawArrays")
           ", "
           (code "glDrawElements")
           ", "
           (code "glMultiDrawElements")
           ", or "
           (code "glDrawRangeElements")
           "
is called. ")
     (heading "Errors")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "size")
           " is not 2, 3, or 4. ")
     (para (code "GL_INVALID_ENUM")
           " is generated if "
           (var "type")
           " is not an accepted value. ")
     (para (code "GL_INVALID_VALUE")
           " is generated if "
           (var "stride")
           " is negative. ")))

(define-gl-procedure
  glVertex
  "glVertex"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glVertex2s"))
      (paramdef "GLshort " (parameter "x"))
      (paramdef "GLshort " (parameter "y"))))
  '(*fragment*
     (heading "specify a vertex")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "x")))
                   (itemx (var "y"))
                   (itemx (var "z"))
                   (itemx (var "w"))
                   (para "
Specify "
                         (var "x")
                         ", "
                         (var "y")
                         ", "
                         (var "z")
                         ", and "
                         (var "w")
                         " coordinates of a vertex.
                    Not all parameters are present in all forms of the command. ")))
     (heading "Description")
     (para (code "glVertex")
           " commands are used within "
           (code "glBegin")
           "/"
           (code "glEnd")
           " pairs to specify
            point, line, and polygon vertices.  The current color, normal, texture
            coordinates, and fog coordinate are associated with the vertex when "
           (code "glVertex")
           "
is called. ")
     (para "
When only "
           (math (var "x"))
           "
and "
           (math (var "y"))
           "
are specified, "
           (math (var "z"))
           "
defaults to 0 and "
           (math (var "w"))
           "
defaults to 1.  When "
           (math (var "x"))
           ", "
           (math (var "y"))
           ",
            and "
           (math (var "z"))
           "
are specified, "
           (math (var "w"))
           "
defaults to 1. ")))

(define-gl-procedure
  glViewport
  "glViewport"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glViewport"))
      (paramdef "GLint " (parameter "x"))
      (paramdef "GLint " (parameter "y"))
      (paramdef "GLsizei " (parameter "width"))
      (paramdef "GLsizei " (parameter "height"))))
  '(*fragment*
     (heading "set the viewport")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "x")))
                   (itemx (var "y"))
                   (para "
Specify the lower left corner of the viewport rectangle,
                    in pixels. The initial value is (0,0). "))
            (entry (% (heading (var "width")))
                   (itemx (var "height"))
                   (para "
Specify the width and height
                    of the viewport.
                    When a GL context is first attached to a window, "
                         (var "width")
                         " and "
                         (var "height")
                         " are set to the dimensions of that
                    window. ")))
     (heading "Description")
     (para (code "glViewport")
           " specifies the affine transformation of "
           (math (var "x"))
           "
and "
           (math (var "y"))
           "
from
            normalized device coordinates to window coordinates.
            Let "
           (math "("
                 (var "x")
                 "_"
                 (var "nd")
                 ","
                 (var "y")
                 "_"
                 (var "nd")
                 ")")
           "
be normalized device coordinates.
            Then the window coordinates "
           (math "("
                 (var "x")
                 "_"
                 (var "w")
                 ","
                 (var "y")
                 "_"
                 (var "w")
                 ")")
           "
are computed as follows: ")
     (para (math (var "x")
                 "_"
                 (var "w")
                 "="
                 "("
                 (var "x")
                 "_"
                 (var "nd")
                 "+"
                 "1"
                 ","
                 ")"
                 "\u2062"
                 "("
                 (var "width")
                 "/"
                 "2"
                 ","
                 ")"
                 "+"
                 (var "x")))
     (para (math (var "y")
                 "_"
                 (var "w")
                 "="
                 "("
                 (var "y")
                 "_"
                 (var "nd")
                 "+"
                 "1"
                 ","
                 ")"
                 "\u2062"
                 "("
                 (var "height")
                 "/"
                 "2"
                 ","
                 ")"
                 "+"
                 (var "y")))
     (para "
Viewport width and height are silently clamped
            to a range that depends on the implementation.
            To query this range, call "
           (code "glGet")
           " with argument "
           (code "GL_MAX_VIEWPORT_DIMS")
           ". ")
     (heading "Errors")
     (para (code "GL_INVALID_VALUE")
           " is generated if either "
           (var "width")
           " or "
           (var "height")
           " is negative. ")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glViewport")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))

(define-gl-procedure
  glWindowPos
  "glWindowPos"
  (funcsynopsis
    (funcprototype
      (funcdef "void " (function "glWindowPos2s"))
      (paramdef "GLshort " (parameter "x"))
      (paramdef "GLshort " (parameter "y"))))
  '(*fragment*
     (heading
       "specify the raster position in window coordinates for pixel operations")
     (heading "Parameters")
     (table (% (formatter (asis)))
            (entry (% (heading (var "x")))
                   (itemx (var "y"))
                   (itemx (var "z"))
                   (para "
Specify the "
                         (math (var "x"))
                         ", "
                         (math (var "y"))
                         ", "
                         (math (var "z"))
                         "
coordinates for the raster position. ")))
     (heading "Description")
     (para "
The GL maintains a 3D position in window coordinates.  This position,
            called the raster position, is used to position pixel and bitmap write
            operations. It is maintained with subpixel accuracy.  See "
           (code "glBitmap")
           ", "
           (code "glDrawPixels")
           ", and "
           (code "glCopyPixels")
           ". ")
     (para (code "glWindowPos2")
           " specifies the "
           (math (var "x"))
           "
and "
           (math (var "y"))
           "
coordinates, while "
           (math (var "z"))
           "
is
            implicitly set to 0. "
           (code "glWindowPos3")
           " specifies all three coordinates.
            The "
           (math (var "w"))
           "
coordinate of the current raster position is always set to 1.0. ")
     (para (code "glWindowPos")
           " directly updates the "
           (math (var "x"))
           "
and "
           (math (var "y"))
           "
coordinates of the current raster
            position with the values specified.  That is, the values are neither
            transformed by the current modelview and projection matrices, nor by
            the viewport-to-window transform.  The "
           (math (var "z"))
           "
coordinate of the current raster
            position is updated in the following manner: ")
     (para (math (var "z")
                 "="
                 "{"
                 "("
                 (var "n")
                 ")"
                 ", "
                 "("
                 (var "f")
                 ")"
                 ", "
                 "("
                 (var "n")
                 "+"
                 (var "z")
                 "×"
                 "("
                 (var "f")
                 "-"
                 (var "n")
                 ","
                 ")"
                 ","
                 ")"
                 "\u2062"
                 "("
                 (var "if")
                 "\u2062"
                 (var "z")
                 "<="
                 "0"
                 ")"
                 ", "
                 "("
                 (var "if")
                 "\u2062"
                 (var "z")
                 ">="
                 "1"
                 ")"
                 ", "
                 "("
                 (code "otherwise")
                 ","
                 ")"
                 ","))
     (para)
     (para "
where "
           (math (var "n"))
           "
is "
           (code "GL_DEPTH_RANGE")
           "'s near value, and "
           (math (var "f"))
           "
is "
           (code "GL_DEPTH_RANGE")
           "'s far value.  See "
           (code "glDepthRange")
           ". ")
     (para "
The specified coordinates are not clip-tested, causing the raster position
            to always be valid. ")
     (para "
The current raster position also includes some associated color data and
            texture coordinates.  If lighting is enabled, then "
           (code "GL_CURRENT_RASTER_COLOR")
           " (in RGBA mode) or "
           (code "GL_CURRENT_RASTER_INDEX")
           "
(in color index mode) is set to the color produced by the lighting
            calculation (see "
           (code "glLight")
           ", "
           (code "glLightModel")
           ", and "
           (code "glShadeModel")
           ").
            If lighting is disabled, current color (in RGBA mode, state variable "
           (code "GL_CURRENT_COLOR")
           ") or color index (in color index mode, state variable "
           (code "GL_CURRENT_INDEX")
           ") is used to update the current raster color. "
           (code "GL_CURRENT_RASTER_SECONDARY_COLOR")
           " (in RGBA mode) is likewise updated. ")
     (para "
Likewise, "
           (code "GL_CURRENT_RASTER_TEXTURE_COORDS")
           " is updated as a function of "
           (code "GL_CURRENT_TEXTURE_COORDS")
           ", based on the texture matrix and the texture
            generation functions (see "
           (code "glTexGen")
           ").  The "
           (code "GL_CURRENT_RASTER_DISTANCE")
           " is set to the "
           (code "GL_CURRENT_FOG_COORD")
           ". ")
     (para)
     (heading "Errors")
     (para (code "GL_INVALID_OPERATION")
           " is generated if "
           (code "glWindowPos")
           "
is executed between the execution of "
           (code "glBegin")
           "
and the corresponding execution of "
           (code "glEnd")
           ". ")))