OpenGL.GL
index
/build/buildd/pyopengl-3.0.0~b3/OpenGL/GL/__init__.py

OpenGL.GL, the core GL library and extensions to it

 
Package Contents
        APPLE (package) -- OpenGL Extensions
ARB (package) -- OpenGL Extensions
ATI (package) -- OpenGL Extensions
DFX (package) -- OpenGL Extensions
EXT (package) -- OpenGL Extensions
GREMEDY (package) -- OpenGL Extensions
HP (package) -- OpenGL Extensions
IBM (package) -- OpenGL Extensions
INGR (package) -- OpenGL Extensions
INTEL (package) -- OpenGL Extensions
MESA (package) -- OpenGL Extensions
NV (package) -- OpenGL Extensions
OES (package) -- OpenGL Extensions
OML (package) -- OpenGL Extensions
PGI (package) -- OpenGL Extensions
REND (package) -- OpenGL Extensions
S3 (package) -- OpenGL Extensions
SGI (package) -- OpenGL Extensions
SGIS (package) -- OpenGL Extensions
SGIX (package) -- OpenGL Extensions
SUN (package) -- OpenGL Extensions
SUNX (package) -- OpenGL Extensions
VERSION (package)
WIN (package) -- OpenGL Extensions
__init__ -- OpenGL.GL, the core GL library and extensions to it
exceptional -- Exceptional cases that need some extra wrapping
feedback -- Utility module to parse a Feedback buffer
glget -- Implementation of the special "glGet" functions
images -- Image-handling routines
pointers -- Implementations for "held-pointers" of various types
selection -- Selection-buffer handling code

 
Functions
       
base_glGetActiveUniform = glGetActiveUniform(...)
glGetActiveUniform( GLuint(program), GLuint(index), GLsizei(bufSize), GLsizeiArray(length), GLintArray(size), GLuintArray(type), GLcharArray(name) ) -> None
base_glGetShaderSource = glGetShaderSource(...)
glGetShaderSource( GLuint(shader), GLsizei(bufSize), GLsizeiArray(length), GLcharArray(source) ) -> None
glAccum(...)
glAccum( GLenum(op), GLfloat(value) ) -> None
glActiveTexture(...)
glActiveTexture( GLenum(texture) ) -> None
glAlphaFunc(...)
glAlphaFunc( GLenum(func), GLclampf(ref) ) -> None
glArrayElement(...)
glArrayElement( GLint(i) ) -> None
glAttachShader(...)
glAttachShader( GLuint(program), GLuint(shader) ) -> None
glBeginQuery(...)
glBeginQuery( GLenum(target), GLuint(id) ) -> None
glBindAttribLocation(...)
glBindAttribLocation( GLuint(program), GLuint(index), GLcharArray(name) ) -> None
glBindBuffer(...)
glBindBuffer( GLenum(target), GLuint(buffer) ) -> None
glBindTexture(...)
glBindTexture( GLenum(target), GLuint(texture) ) -> None
glBitmap( width,height,xorig,yorig,xmove,ymove,bitmap )
pyConverters: width=None, height=None, xorig=None, yorig=None, xmove=None, ymove=None, bitmap=<OpenGL.converters.CallFuncPyConverter object at 0x828d42c>
cConverters: width=None, height=None, xorig=None, yorig=None, xmove=None, ymove=None, bitmap=<OpenGL.converters.getPyArgsName object at 0x8666b1c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glBitmap( GLsizei(width), GLsizei(height), GLfloat(xorig), GLfloat(yorig), GLfloat(xmove), GLfloat(ymove), arrays.GLubyteArray(bitmap) ) -> None
glBlendColor(...)
glBlendColor( GLclampf(red), GLclampf(green), GLclampf(blue), GLclampf(alpha) ) -> None
glBlendEquation(...)
glBlendEquation( GLenum(mode) ) -> None
glBlendEquationSeparate(...)
glBlendEquationSeparate( GLenum(modeRGB), GLenum(modeAlpha) ) -> None
glBlendFunc(...)
glBlendFunc( GLenum(sfactor), GLenum(dfactor) ) -> None
glBlendFuncSeparate(...)
glBlendFuncSeparate( GLenum(sfactorRGB), GLenum(dfactorRGB), GLenum(sfactorAlpha), GLenum(dfactorAlpha) ) -> None
glBufferData(...)
glBufferData( GLenum(target), GLsizeiptr(size), c_void_p(data), GLenum(usage) ) -> None
glBufferSubData(...)
glBufferSubData( GLenum(target), GLintptr(offset), GLsizeiptr(size), c_void_p(data) ) -> None
glCallList(...)
glCallList( GLuint(list) ) -> None
glClear(...)
glClear( GLbitfield(mask) ) -> None
glClearAccum(...)
glClearAccum( GLfloat(red), GLfloat(green), GLfloat(blue), GLfloat(alpha) ) -> None
glClearColor(...)
glClearColor( GLclampf(red), GLclampf(green), GLclampf(blue), GLclampf(alpha) ) -> None
glClearDepth(...)
glClearDepth( GLclampd(depth) ) -> None
glClearIndex(...)
glClearIndex( GLfloat(c) ) -> None
glClearStencil(...)
glClearStencil( GLint(s) ) -> None
glClientActiveTexture(...)
glClientActiveTexture( GLenum(texture) ) -> None
glClipPlane( plane,equation )
pyConverters: plane=None, equation=<OpenGL.converters.CallFuncPyConverter object at 0x828da6c>
cConverters: plane=None, equation=<OpenGL.converters.getPyArgsName object at 0x8666b94>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glClipPlane( GLenum(plane), arrays.GLdoubleArray(equation) ) -> None
glColor3b(...)
glColor3b( GLbyte(red), GLbyte(green), GLbyte(blue) ) -> None
glColor3bv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8666c0c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glColor3bv( arrays.GLbyteArray(v) ) -> None
glColor3d(...)
glColor3d( GLdouble(red), GLdouble(green), GLdouble(blue) ) -> None
glColor3dv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8666cac>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glColor3dv( arrays.GLdoubleArray(v) ) -> None
glColor3f(...)
glColor3f( GLfloat(red), GLfloat(green), GLfloat(blue) ) -> None
glColor3fv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8666d4c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glColor3fv( arrays.GLfloatArray(v) ) -> None
glColor3i(...)
glColor3i( GLint(red), GLint(green), GLint(blue) ) -> None
glColor3iv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8666dec>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glColor3iv( arrays.GLintArray(v) ) -> None
glColor3s(...)
glColor3s( GLshort(red), GLshort(green), GLshort(blue) ) -> None
glColor3sv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8666e8c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glColor3sv( arrays.GLshortArray(v) ) -> None
glColor3ub(...)
glColor3ub( GLubyte(red), GLubyte(green), GLubyte(blue) ) -> None
glColor3ubv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8666f2c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glColor3ubv( arrays.GLubyteArray(v) ) -> None
glColor3ui(...)
glColor3ui( GLuint(red), GLuint(green), GLuint(blue) ) -> None
glColor3uiv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8666fcc>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glColor3uiv( arrays.GLuintArray(v) ) -> None
glColor3us(...)
glColor3us( GLushort(red), GLushort(green), GLushort(blue) ) -> None
glColor3usv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b4c0a4>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glColor3usv( arrays.GLushortArray(v) ) -> None
glColor4b(...)
glColor4b( GLbyte(red), GLbyte(green), GLbyte(blue), GLbyte(alpha) ) -> None
glColor4bv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b4c144>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glColor4bv( arrays.GLbyteArray(v) ) -> None
glColor4d(...)
glColor4d( GLdouble(red), GLdouble(green), GLdouble(blue), GLdouble(alpha) ) -> None
glColor4dv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b4c1e4>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glColor4dv( arrays.GLdoubleArray(v) ) -> None
glColor4f(...)
glColor4f( GLfloat(red), GLfloat(green), GLfloat(blue), GLfloat(alpha) ) -> None
glColor4fv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b4c284>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glColor4fv( arrays.GLfloatArray(v) ) -> None
glColor4i(...)
glColor4i( GLint(red), GLint(green), GLint(blue), GLint(alpha) ) -> None
glColor4iv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b4c324>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glColor4iv( arrays.GLintArray(v) ) -> None
glColor4s(...)
glColor4s( GLshort(red), GLshort(green), GLshort(blue), GLshort(alpha) ) -> None
glColor4sv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b4c3c4>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glColor4sv( arrays.GLshortArray(v) ) -> None
glColor4ub(...)
glColor4ub( GLubyte(red), GLubyte(green), GLubyte(blue), GLubyte(alpha) ) -> None
glColor4ubv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b4c464>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glColor4ubv( arrays.GLubyteArray(v) ) -> None
glColor4ui(...)
glColor4ui( GLuint(red), GLuint(green), GLuint(blue), GLuint(alpha) ) -> None
glColor4uiv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b4c504>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glColor4uiv( arrays.GLuintArray(v) ) -> None
glColor4us(...)
glColor4us( GLushort(red), GLushort(green), GLushort(blue), GLushort(alpha) ) -> None
glColor4usv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b4c5a4>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glColor4usv( arrays.GLushortArray(v) ) -> None
glColorMask(...)
glColorMask( GLboolean(red), GLboolean(green), GLboolean(blue), GLboolean(alpha) ) -> None
glColorMaterial(...)
glColorMaterial( GLenum(face), GLenum(mode) ) -> None
glColorPointer( size,type,stride,pointer )
pyConverters: size=None, type=None, stride=None, pointer=<OpenGL.arrays.arrayhelpers.AsArrayOfType object at 0x82a7bec>
cConverters: Not Used
cResolvers: size=None, type=None, stride=None, pointer=
voidDataPointer(cls, value) method of type instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object at 0x82a7acc>
returnValues: <OpenGL.converters.returnPyArgument object at 0x8b5eeb4>
Wrapping Operation: glColorPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glColorPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object at 0x87c120c>
cConverters: size=
arraySizeOfFirst(pyArgs, index, baseOperation)
Return the array size of the first argument
, type=GL_BYTE, stride=0, pointer=<OpenGL.converters.getPyArgsName object at 0x87ab89c>
cResolvers: size=None, type=None, stride=None, pointer=
voidDataPointer(cls, value) method of _ctypes.PointerType instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object at 0x87c136c>
returnValues: <OpenGL.converters.returnPyArgument object at 0x87ab8ec>
Wrapping Operation: glColorPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glColorPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object at 0x87c122c>
cConverters: size=
arraySizeOfFirst(pyArgs, index, baseOperation)
Return the array size of the first argument
, type=GL_DOUBLE, stride=0, pointer=<OpenGL.converters.getPyArgsName object at 0x87ab4b4>
cResolvers: size=None, type=None, stride=None, pointer=
voidDataPointer(cls, value) method of _ctypes.PointerType instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object at 0x87c14cc>
returnValues: <OpenGL.converters.returnPyArgument object at 0x87ab504>
Wrapping Operation: glColorPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glColorPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object at 0x87c170c>
cConverters: size=
arraySizeOfFirst(pyArgs, index, baseOperation)
Return the array size of the first argument
, type=GL_FLOAT, stride=0, pointer=<OpenGL.converters.getPyArgsName object at 0x87ab57c>
cResolvers: size=None, type=None, stride=None, pointer=
voidDataPointer(cls, value) method of _ctypes.PointerType instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object at 0x87c1a8c>
returnValues: <OpenGL.converters.returnPyArgument object at 0x87ab5cc>
Wrapping Operation: glColorPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glColorPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object at 0x87c12cc>
cConverters: size=
arraySizeOfFirst(pyArgs, index, baseOperation)
Return the array size of the first argument
, type=GL_INT, stride=0, pointer=<OpenGL.converters.getPyArgsName object at 0x87ab644>
cResolvers: size=None, type=None, stride=None, pointer=
voidDataPointer(cls, value) method of _ctypes.PointerType instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object at 0x87c108c>
returnValues: <OpenGL.converters.returnPyArgument object at 0x87ab694>
Wrapping Operation: glColorPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glColorPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object at 0x87c1ecc>
cConverters: size=
arraySizeOfFirst(pyArgs, index, baseOperation)
Return the array size of the first argument
, type=GL_SHORT, stride=0, pointer=<OpenGL.converters.getPyArgsName object at 0x87ab70c>
cResolvers: size=None, type=None, stride=None, pointer=
voidDataPointer(cls, value) method of _ctypes.PointerType instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object at 0x87c16cc>
returnValues: <OpenGL.converters.returnPyArgument object at 0x87ab75c>
Wrapping Operation: glColorPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glColorPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object at 0x87c1bec>
cConverters: size=
arraySizeOfFirst(pyArgs, index, baseOperation)
Return the array size of the first argument
, type=GL_UNSIGNED_BYTE, stride=0, pointer=<OpenGL.converters.getPyArgsName object at 0x87ab7d4>
cResolvers: size=None, type=None, stride=None, pointer=
voidDataPointer(cls, value) method of _ctypes.PointerType instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object at 0x87c1b4c>
returnValues: <OpenGL.converters.returnPyArgument object at 0x87ab824>
Wrapping Operation: glColorPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glColorPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object at 0x87c1e0c>
cConverters: size=
arraySizeOfFirst(pyArgs, index, baseOperation)
Return the array size of the first argument
, type=GL_UNSIGNED_INT, stride=0, pointer=<OpenGL.converters.getPyArgsName object at 0x87ab964>
cResolvers: size=None, type=None, stride=None, pointer=
voidDataPointer(cls, value) method of _ctypes.PointerType instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object at 0x87c118c>
returnValues: <OpenGL.converters.returnPyArgument object at 0x87ab9b4>
Wrapping Operation: glColorPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glColorPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object at 0x87c182c>
cConverters: size=
arraySizeOfFirst(pyArgs, index, baseOperation)
Return the array size of the first argument
, type=GL_UNSIGNED_SHORT, stride=0, pointer=<OpenGL.converters.getPyArgsName object at 0x87aba2c>
cResolvers: size=None, type=None, stride=None, pointer=
voidDataPointer(cls, value) method of _ctypes.PointerType instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object at 0x87c1f6c>
returnValues: <OpenGL.converters.returnPyArgument object at 0x87aba7c>
Wrapping Operation: glColorPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glColorSubTable( target,start,count,format,type,data )
pyConverters: target=None, start=
asIntConverter(value, *args)
, count=
asIntConverter(value, *args)
, format=None, type=None, data=<OpenGL.GL.images.ImageInputConverter object at 0x827ffac>
cConverters: Not Used
cResolvers: target=None, start=None, count=None, format=None, type=None, data=
cResolver(self, array) method of ImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glColorSubTable( GLenum(target), GLsizei(start), GLsizei(count), GLenum(format), GLenum(type), c_void_p(data) ) -> None
glColorTable( target,internalformat,width,format,type,table )
pyConverters: target=None, internalformat=None, width=
asIntConverter(value, *args)
, format=None, type=None, table=<OpenGL.GL.images.ImageInputConverter object at 0x827fd2c>
cConverters: Not Used
cResolvers: target=None, internalformat=None, width=None, format=None, type=None, table=
cResolver(self, array) method of ImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glColorTable( GLenum(target), GLenum(internalformat), GLsizei(width), GLenum(format), GLenum(type), c_void_p(table) ) -> None
glColorTableParameterfv( target,pname,params )
pyConverters: target=None, pname=None, params=
asArraySize(incoming, function, args)
cConverters: target=None, pname=None, params=<OpenGL.converters.getPyArgsName object at 0x879f34c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glColorTableParameterfv( GLenum(target), GLenum(pname), GLfloatArray(params) ) -> None
glColorTableParameteriv(...)
glColorTableParameteriv( GLenum(target), GLenum(pname), GLintArray(params) ) -> None
glCompileShader(...)
glCompileShader( GLuint(shader) ) -> None
glCompressedTexImage1D( target,level,internalformat,width,border,data )
pyConverters: target=None, level=None, internalformat=None, width=
asIntConverter(value, *args)
, border=None, data=None
cConverters: target=None, level=None, internalformat=None, width=None, border=None, imageSize=<OpenGL.GL.images.CompressedImageConverter object at 0x823e56c>, data=None
cResolvers: Not Used
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glCompressedTexImage1D( GLenum(target), GLint(level), GLenum(internalformat), GLsizei(width), GLint(border), GLsizei(imageSize), c_void_p(data) ) -> None
glCompressedTexImage2D( target,level,internalformat,width,height,border,data )
pyConverters: target=None, level=None, internalformat=None, width=
asIntConverter(value, *args)
, height=
asIntConverter(value, *args)
, border=None, data=None
cConverters: target=None, level=None, internalformat=None, width=None, height=None, border=None, imageSize=<OpenGL.GL.images.CompressedImageConverter object at 0x823e7ec>, data=None
cResolvers: Not Used
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glCompressedTexImage2D( GLenum(target), GLint(level), GLenum(internalformat), GLsizei(width), GLsizei(height), GLint(border), GLsizei(imageSize), c_void_p(data) ) -> None
glCompressedTexImage3D( target,level,internalformat,width,height,depth,border,data )
pyConverters: target=None, level=None, internalformat=None, width=
asIntConverter(value, *args)
, height=
asIntConverter(value, *args)
, depth=
asIntConverter(value, *args)
, border=None, data=None
cConverters: target=None, level=None, internalformat=None, width=None, height=None, depth=None, border=None, imageSize=<OpenGL.GL.images.CompressedImageConverter object at 0x828abcc>, data=None
cResolvers: Not Used
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glCompressedTexImage3D( GLenum(target), GLint(level), GLenum(internalformat), GLsizei(width), GLsizei(height), GLsizei(depth), GLint(border), GLsizei(imageSize), c_void_p(data) ) -> None
glCompressedTexSubImage1D( target,level,xoffset,width,format,data )
pyConverters: target=None, level=None, xoffset=
asIntConverter(value, *args)
, width=
asIntConverter(value, *args)
, format=None, data=None
cConverters: target=None, level=None, xoffset=None, width=None, format=None, imageSize=<OpenGL.GL.images.CompressedImageConverter object at 0x823e60c>, data=None
cResolvers: Not Used
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glCompressedTexSubImage1D( GLenum(target), GLint(level), GLint(xoffset), GLsizei(width), GLenum(format), GLsizei(imageSize), c_void_p(data) ) -> None
glCompressedTexSubImage2D( target,level,xoffset,yoffset,width,height,format,data )
pyConverters: target=None, level=None, xoffset=
asIntConverter(value, *args)
, yoffset=
asIntConverter(value, *args)
, width=
asIntConverter(value, *args)
, height=
asIntConverter(value, *args)
, format=None, data=None
cConverters: target=None, level=None, xoffset=None, yoffset=None, width=None, height=None, format=None, imageSize=<OpenGL.GL.images.CompressedImageConverter object at 0x828a7ec>, data=None
cResolvers: Not Used
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glCompressedTexSubImage2D( GLenum(target), GLint(level), GLint(xoffset), GLint(yoffset), GLsizei(width), GLsizei(height), GLenum(format), GLsizei(imageSize), c_void_p(data) ) -> None
glCompressedTexSubImage3D( target,level,xoffset,yoffset,zoffset,width,height,depth,format,data )
pyConverters: target=None, level=None, xoffset=
asIntConverter(value, *args)
, yoffset=
asIntConverter(value, *args)
, zoffset=
asIntConverter(value, *args)
, width=
asIntConverter(value, *args)
, height=
asIntConverter(value, *args)
, depth=
asIntConverter(value, *args)
, format=None, data=None
cConverters: target=None, level=None, xoffset=None, yoffset=None, zoffset=None, width=None, height=None, depth=None, format=None, imageSize=<OpenGL.GL.images.CompressedImageConverter object at 0x828a6ac>, data=None
cResolvers: Not Used
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glCompressedTexSubImage3D( GLenum(target), GLint(level), GLint(xoffset), GLint(yoffset), GLint(zoffset), GLsizei(width), GLsizei(height), GLsizei(depth), GLenum(format), GLsizei(imageSize), c_void_p(data) ) -> None
glConvolutionFilter1D( target,internalformat,width,format,type,image )
pyConverters: target=None, internalformat=None, width=
asIntConverter(value, *args)
, format=None, type=None, image=<OpenGL.GL.images.ImageInputConverter object at 0x827f76c>
cConverters: Not Used
cResolvers: target=None, internalformat=None, width=None, format=None, type=None, image=
cResolver(self, array) method of ImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glConvolutionFilter1D( GLenum(target), GLenum(internalformat), GLsizei(width), GLenum(format), GLenum(type), c_void_p(image) ) -> None
glConvolutionFilter2D( target,internalformat,width,height,format,type,image )
pyConverters: target=None, internalformat=None, width=
asIntConverter(value, *args)
, height=
asIntConverter(value, *args)
, format=None, type=None, image=<OpenGL.GL.images.ImageInputConverter object at 0x827f32c>
cConverters: Not Used
cResolvers: target=None, internalformat=None, width=None, height=None, format=None, type=None, image=
cResolver(self, array) method of ImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glConvolutionFilter2D( GLenum(target), GLenum(internalformat), GLsizei(width), GLsizei(height), GLenum(format), GLenum(type), c_void_p(image) ) -> None
glConvolutionParameterf(...)
glConvolutionParameterf( GLenum(target), GLenum(pname), GLfloat(params) ) -> None
glConvolutionParameterfv(...)
glConvolutionParameterfv( GLenum(target), GLenum(pname), GLfloatArray(params) ) -> None
glConvolutionParameteri(...)
glConvolutionParameteri( GLenum(target), GLenum(pname), GLint(params) ) -> None
glConvolutionParameteriv(...)
glConvolutionParameteriv( GLenum(target), GLenum(pname), GLintArray(params) ) -> None
glCopyColorSubTable(...)
glCopyColorSubTable( GLenum(target), GLsizei(start), GLint(x), GLint(y), GLsizei(width) ) -> None
glCopyColorTable(...)
glCopyColorTable( GLenum(target), GLenum(internalformat), GLint(x), GLint(y), GLsizei(width) ) -> None
glCopyConvolutionFilter1D(...)
glCopyConvolutionFilter1D( GLenum(target), GLenum(internalformat), GLint(x), GLint(y), GLsizei(width) ) -> None
glCopyConvolutionFilter2D(...)
glCopyConvolutionFilter2D( GLenum(target), GLenum(internalformat), GLint(x), GLint(y), GLsizei(width), GLsizei(height) ) -> None
glCopyPixels(...)
glCopyPixels( GLint(x), GLint(y), GLsizei(width), GLsizei(height), GLenum(type) ) -> None
glCopyTexImage1D(...)
glCopyTexImage1D( GLenum(target), GLint(level), GLenum(internalFormat), GLint(x), GLint(y), GLsizei(width), GLint(border) ) -> None
glCopyTexImage2D(...)
glCopyTexImage2D( GLenum(target), GLint(level), GLenum(internalFormat), GLint(x), GLint(y), GLsizei(width), GLsizei(height), GLint(border) ) -> None
glCopyTexSubImage1D(...)
glCopyTexSubImage1D( GLenum(target), GLint(level), GLint(xoffset), GLint(x), GLint(y), GLsizei(width) ) -> None
glCopyTexSubImage2D(...)
glCopyTexSubImage2D( GLenum(target), GLint(level), GLint(xoffset), GLint(yoffset), GLint(x), GLint(y), GLsizei(width), GLsizei(height) ) -> None
glCopyTexSubImage3D(...)
glCopyTexSubImage3D( GLenum(target), GLint(level), GLint(xoffset), GLint(yoffset), GLint(zoffset), GLint(x), GLint(y), GLsizei(width), GLsizei(height) ) -> None
glCreateProgram(...)
glCreateProgram(  ) -> constants.GLuint
glCreateShader(...)
glCreateShader( GLenum(type) ) -> constants.GLuint
glCullFace(...)
glCullFace( GLenum(mode) ) -> None
glDeleteBuffers(...)
glDeleteBuffers( GLsizei(n), GLuintArray(buffers) ) -> None
glDeleteLists(...)
glDeleteLists( GLuint(list), GLsizei(range) ) -> None
glDeleteProgram(...)
glDeleteProgram( GLuint(program) ) -> None
glDeleteQueries(...)
glDeleteQueries( GLsizei(n), GLuintArray(ids) ) -> None
glDeleteShader(...)
glDeleteShader( GLuint(shader) ) -> None
glDepthFunc(...)
glDepthFunc( GLenum(func) ) -> None
glDepthMask(...)
glDepthMask( GLboolean(flag) ) -> None
glDepthRange(...)
glDepthRange( GLclampd(zNear), GLclampd(zFar) ) -> None
glDetachShader(...)
glDetachShader( GLuint(program), GLuint(shader) ) -> None
glDisable(...)
glDisable( GLenum(cap) ) -> None
glDisableClientState(...)
glDisableClientState( GLenum(array) ) -> None
glDisableVertexAttribArray(...)
glDisableVertexAttribArray( GLuint(index) ) -> None
glDrawArrays(...)
glDrawArrays( GLenum(mode), GLint(first), GLsizei(count) ) -> None
glDrawBuffer(...)
glDrawBuffer( GLenum(mode) ) -> None
glDrawBuffers(...)
glDrawBuffers( GLsizei(n), GLuintArray(bufs) ) -> None
glDrawElements( mode,count,type,indices )
pyConverters: mode=None, count=None, type=None, indices=<OpenGL.arrays.arrayhelpers.AsArrayOfType object at 0x82a7e8c>
cConverters: Not Used
cResolvers: mode=None, count=None, type=None, indices=
voidDataPointer(cls, value) method of type instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: Not Used
returnValues: <OpenGL.converters.returnPyArgument object at 0x8b5ef7c>
Wrapping Operation: glDrawElements( GLenum(mode), GLsizei(count), GLenum(type), POINTER(GLvoid)(indices) ) -> None
glDrawElements( mode,indices )
pyConverters: mode=None, indices=<OpenGL.arrays.arrayhelpers.AsArrayTyped object at 0x82a7f2c>
cConverters: mode=None, count=<OpenGL.arrays.arrayhelpers.AsArrayTypedSize object at 0x82a788c>, type=GL_UNSIGNED_BYTE, indices=None
cResolvers: mode=None, count=None, type=None, indices=
voidDataPointer(cls, value) method of _ctypes.PointerType instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: Not Used
returnValues: <OpenGL.converters.returnPyArgument object at 0x8b6602c>
Wrapping Operation: glDrawElements( GLenum(mode), GLsizei(count), GLenum(type), POINTER(GLvoid)(indices) ) -> None
glDrawElements( mode,indices )
pyConverters: mode=None, indices=<OpenGL.arrays.arrayhelpers.AsArrayTyped object at 0x82a734c>
cConverters: mode=None, count=<OpenGL.arrays.arrayhelpers.AsArrayTypedSize object at 0x82a772c>, type=GL_UNSIGNED_INT, indices=None
cResolvers: mode=None, count=None, type=None, indices=
voidDataPointer(cls, value) method of _ctypes.PointerType instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: Not Used
returnValues: <OpenGL.converters.returnPyArgument object at 0x8b660cc>
Wrapping Operation: glDrawElements( GLenum(mode), GLsizei(count), GLenum(type), POINTER(GLvoid)(indices) ) -> None
glDrawElements( mode,indices )
pyConverters: mode=None, indices=<OpenGL.arrays.arrayhelpers.AsArrayTyped object at 0x82a704c>
cConverters: mode=None, count=<OpenGL.arrays.arrayhelpers.AsArrayTypedSize object at 0x82a7fac>, type=GL_UNSIGNED_SHORT, indices=None
cResolvers: mode=None, count=None, type=None, indices=
voidDataPointer(cls, value) method of _ctypes.PointerType instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: Not Used
returnValues: <OpenGL.converters.returnPyArgument object at 0x8b6616c>
Wrapping Operation: glDrawElements( GLenum(mode), GLsizei(count), GLenum(type), POINTER(GLvoid)(indices) ) -> None
glDrawPixels( width,height,format,type,pixels )
pyConverters: width=
asIntConverter(value, *args)
, height=
asIntConverter(value, *args)
, format=None, type=None, pixels=<OpenGL.GL.images.ImageInputConverter object at 0x82530cc>
cConverters: Not Used
cResolvers: width=None, height=None, format=None, type=None, pixels=
cResolver(self, array) method of ImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glDrawPixels( GLsizei(width), GLsizei(height), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glDrawPixels( format,pixels )
pyConverters: format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x8293c6c>
cConverters: width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, height=
height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the height from the pixels argument
, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: width=None, height=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glDrawPixels( GLsizei(width), GLsizei(height), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glDrawPixels( format,pixels )
pyConverters: format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x8293dec>
cConverters: width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, height=
height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the height from the pixels argument
, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: width=None, height=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glDrawPixels( GLsizei(width), GLsizei(height), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glDrawPixels( format,pixels )
pyConverters: format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x87cf78c>
cConverters: width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, height=
height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the height from the pixels argument
, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: width=None, height=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glDrawPixels( GLsizei(width), GLsizei(height), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glDrawPixels( format,pixels )
pyConverters: format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x87cfbcc>
cConverters: width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, height=
height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the height from the pixels argument
, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: width=None, height=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glDrawPixels( GLsizei(width), GLsizei(height), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glDrawPixels( format,pixels )
pyConverters: format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x87ccdac>
cConverters: width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, height=
height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the height from the pixels argument
, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: width=None, height=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glDrawPixels( GLsizei(width), GLsizei(height), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glDrawPixels( format,pixels )
pyConverters: format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x87cc44c>
cConverters: width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, height=
height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the height from the pixels argument
, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: width=None, height=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glDrawPixels( GLsizei(width), GLsizei(height), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glDrawPixels( format,pixels )
pyConverters: format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x825234c>
cConverters: width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, height=
height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the height from the pixels argument
, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: width=None, height=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glDrawPixels( GLsizei(width), GLsizei(height), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glDrawRangeElements( mode,start,end,count,type,indices )
pyConverters: mode=None, start=None, end=None, count=None, type=None, indices=<OpenGL.arrays.arrayhelpers.AsArrayOfType object at 0x86374cc>
cConverters: Not Used
cResolvers: mode=None, start=None, end=None, count=None, type=None, indices=
voidDataPointer(cls, value) method of type instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: Not Used
returnValues: <OpenGL.converters.returnPyArgument object at 0x879f4dc>
Wrapping Operation: glDrawRangeElements( GLenum(mode), GLuint(start), GLuint(end), GLsizei(count), GLenum(type), c_void_p(indices) ) -> None
glEdgeFlag(...)
glEdgeFlag( GLboolean(flag) ) -> None
glEdgeFlagPointer( stride,pointer )
pyConverters: stride=None, pointer=<OpenGL.arrays.arrayhelpers.AsArrayTyped object at 0x82a708c>
cConverters: Not Used
cResolvers: stride=None, pointer=
voidDataPointer(cls, value) method of type instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object at 0x82a776c>
returnValues: <OpenGL.converters.returnPyArgument object at 0x8b5ee3c>
Wrapping Operation: glEdgeFlagPointer( GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glEdgeFlagPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object at 0x87c10ac>
cConverters: stride=0, pointer=<OpenGL.converters.getPyArgsName object at 0x87abaf4>
cResolvers: stride=None, pointer=
voidDataPointer(cls, value) method of _ctypes.PointerType instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object at 0x87c15ec>
returnValues: <OpenGL.converters.returnPyArgument object at 0x87abb44>
Wrapping Operation: glEdgeFlagPointer( GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glEdgeFlagv( flag )
pyConverters: flag=
asArraySize(incoming, function, args)
cConverters: flag=<OpenGL.converters.getPyArgsName object at 0x87a7644>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glEdgeFlagv( POINTER(GLboolean)(flag) ) -> None
glEnable(...)
glEnable( GLenum(cap) ) -> None
glEnableClientState(...)
glEnableClientState( GLenum(array) ) -> None
glEnableVertexAttribArray(...)
glEnableVertexAttribArray( GLuint(index) ) -> None
glEndList(...)
glEndList(  ) -> None
glEndQuery(...)
glEndQuery( GLenum(target) ) -> None
glEvalCoord1d(...)
glEvalCoord1d( GLdouble(u) ) -> None
glEvalCoord1dv( u )
pyConverters: u=
asArraySize(incoming, function, args)
cConverters: u=<OpenGL.converters.getPyArgsName object at 0x8b4c6bc>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glEvalCoord1dv( arrays.GLdoubleArray(u) ) -> None
glEvalCoord1f(...)
glEvalCoord1f( GLfloat(u) ) -> None
glEvalCoord1fv( u )
pyConverters: u=
asArraySize(incoming, function, args)
cConverters: u=<OpenGL.converters.getPyArgsName object at 0x8b4c75c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glEvalCoord1fv( arrays.GLfloatArray(u) ) -> None
glEvalCoord2d(...)
glEvalCoord2d( GLdouble(u), GLdouble(v) ) -> None
glEvalCoord2dv( u )
pyConverters: u=
asArraySize(incoming, function, args)
cConverters: u=<OpenGL.converters.getPyArgsName object at 0x8b4c7fc>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glEvalCoord2dv( arrays.GLdoubleArray(u) ) -> None
glEvalCoord2f(...)
glEvalCoord2f( GLfloat(u), GLfloat(v) ) -> None
glEvalCoord2fv( u )
pyConverters: u=
asArraySize(incoming, function, args)
cConverters: u=<OpenGL.converters.getPyArgsName object at 0x8b4c89c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glEvalCoord2fv( arrays.GLfloatArray(u) ) -> None
glEvalMesh1(...)
glEvalMesh1( GLenum(mode), GLint(i1), GLint(i2) ) -> None
glEvalMesh2(...)
glEvalMesh2( GLenum(mode), GLint(i1), GLint(i2), GLint(j1), GLint(j2) ) -> None
glEvalPoint1(...)
glEvalPoint1( GLint(i) ) -> None
glEvalPoint2(...)
glEvalPoint2( GLint(i), GLint(j) ) -> None
glFinish(...)
glFinish(  ) -> None
glFlush(...)
glFlush(  ) -> None
glFogCoordPointer(...)
glFogCoordPointer( GLenum(type), GLsizei(stride), c_void_p(pointer) ) -> None
glFogCoordd(...)
glFogCoordd( GLdouble(coord) ) -> None
glFogCoorddv(...)
glFogCoorddv( GLdoubleArray(coord) ) -> None
glFogCoordf(...)
glFogCoordf( GLfloat(coord) ) -> None
glFogCoordfv(...)
glFogCoordfv( GLfloatArray(coord) ) -> None
glFogf(...)
glFogf( GLenum(pname), GLfloat(param) ) -> None
glFogfv( pname,params )
pyConverters: pname=None, params=<OpenGL.converters.CallFuncPyConverter object at 0x87f7dec>
cConverters: pname=None, params=<OpenGL.converters.getPyArgsName object at 0x8b4c9b4>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glFogfv( GLenum(pname), arrays.GLfloatArray(params) ) -> None
glFogi(...)
glFogi( GLenum(pname), GLint(param) ) -> None
glFogiv( pname,params )
pyConverters: pname=None, params=<OpenGL.converters.CallFuncPyConverter object at 0x87f98cc>
cConverters: pname=None, params=<OpenGL.converters.getPyArgsName object at 0x8b4ca2c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glFogiv( GLenum(pname), arrays.GLintArray(params) ) -> None
glFrontFace(...)
glFrontFace( GLenum(mode) ) -> None
glFrustum(...)
glFrustum( GLdouble(left), GLdouble(right), GLdouble(bottom), GLdouble(top), GLdouble(zNear), GLdouble(zFar) ) -> None
glGenBuffers(...)
glGenBuffers( GLsizei(n), GLuintArray(buffers) ) -> None
glGenLists(...)
glGenLists( GLsizei(range) ) -> GLuint
glGenQueries(...)
glGenQueries( GLsizei(n), GLuintArray(ids) ) -> None
glGetActiveAttrib(...)
glGetActiveAttrib( GLuint(program), GLuint(index), GLsizei(bufSize), GLsizeiArray(length), GLintArray(size), GLuintArray(type), GLcharArray(name) ) -> None
glGetAttachedShaders(...)
glGetAttachedShaders( GLuint(program), GLsizei(maxCount), GLsizeiArray(count), GLuintArray(obj) ) -> None
glGetAttribLocation(...)
glGetAttribLocation( GLuint(program), GLcharArray(name) ) -> constants.GLint
glGetIntegerv( pname )
pyConverters: pname=None
cConverters: pname=None, params=<OpenGL.converters.SizedOutput object at 0x829fb1c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
oldStyleReturn(self, result, baseOperation, pyArgs, cArgs) method of SizedOutput instance
Retrieve cArgs[ self.index ]
Wrapping Operation: glGetIntegerv( GLenum(pname), arrays.GLintArray(params) ) -> None
glGetIntegerv( pname )
pyConverters: pname=None
cConverters: pname=None, params=<OpenGL.converters.SizedOutput object at 0x829fb1c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
oldStyleReturn(self, result, baseOperation, pyArgs, cArgs) method of SizedOutput instance
Retrieve cArgs[ self.index ]
Wrapping Operation: glGetIntegerv( GLenum(pname), arrays.GLintArray(params) ) -> None
glGetBufferParameteriv(...)
glGetBufferParameteriv( GLenum(target), GLenum(pname), GLintArray(params) ) -> None
glGetBufferPointerv(...)
glGetBufferPointerv( GLenum(target), GLenum(pname), POINTER(ctypes.c_void_p)(params) ) -> None
glGetBufferSubData(...)
glGetBufferSubData( GLenum(target), GLintptr(offset), GLsizeiptr(size), c_void_p(data) ) -> None
glGetClipPlane( plane,equation )
pyConverters: plane=None, equation=<OpenGL.converters.CallFuncPyConverter object at 0x87f934c>
cConverters: plane=None, equation=<OpenGL.converters.getPyArgsName object at 0x8b4cb1c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glGetClipPlane( GLenum(plane), arrays.GLdoubleArray(equation) ) -> None
glGetColorTableParameterfv( target,pname )
pyConverters: target=None, pname=None
cConverters: target=None, pname=None, params=<OpenGL.converters.SizedOutput object at 0x856409c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
oldStyleReturn(self, result, baseOperation, pyArgs, cArgs) method of SizedOutput instance
Retrieve cArgs[ self.index ]
Wrapping Operation: glGetColorTableParameterfv( GLenum(target), GLenum(pname), GLfloatArray(params) ) -> None
glGetColorTableParameteriv( target,pname )
pyConverters: target=None, pname=None
cConverters: target=None, pname=None, params=<OpenGL.converters.SizedOutput object at 0x856410c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
oldStyleReturn(self, result, baseOperation, pyArgs, cArgs) method of SizedOutput instance
Retrieve cArgs[ self.index ]
Wrapping Operation: glGetColorTableParameteriv( GLenum(target), GLenum(pname), GLintArray(params) ) -> None
glGetConvolutionParameterfv( target,pname )
pyConverters: target=None, pname=None
cConverters: target=None, pname=None, params=<OpenGL.converters.SizedOutput object at 0x85641ec>
cResolvers: Not Used
storeValues: Not Used
returnValues:
oldStyleReturn(self, result, baseOperation, pyArgs, cArgs) method of SizedOutput instance
Retrieve cArgs[ self.index ]
Wrapping Operation: glGetConvolutionParameterfv( GLenum(target), GLenum(pname), GLfloatArray(params) ) -> None
glGetConvolutionParameteriv( target,pname )
pyConverters: target=None, pname=None
cConverters: target=None, pname=None, params=<OpenGL.converters.SizedOutput object at 0x856417c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
oldStyleReturn(self, result, baseOperation, pyArgs, cArgs) method of SizedOutput instance
Retrieve cArgs[ self.index ]
Wrapping Operation: glGetConvolutionParameteriv( GLenum(target), GLenum(pname), GLintArray(params) ) -> None
glGetDoublev( pname )
pyConverters: pname=None
cConverters: pname=None, params=<OpenGL.converters.SizedOutput object at 0x827d8b4>
cResolvers: Not Used
storeValues: Not Used
returnValues:
oldStyleReturn(self, result, baseOperation, pyArgs, cArgs) method of SizedOutput instance
Retrieve cArgs[ self.index ]
Wrapping Operation: glGetDoublev( GLenum(pname), arrays.GLdoubleArray(params) ) -> None
glGetDoublev( pname )
pyConverters: pname=None
cConverters: pname=None, params=<OpenGL.converters.SizedOutput object at 0x827d8b4>
cResolvers: Not Used
storeValues: Not Used
returnValues:
oldStyleReturn(self, result, baseOperation, pyArgs, cArgs) method of SizedOutput instance
Retrieve cArgs[ self.index ]
Wrapping Operation: glGetDoublev( GLenum(pname), arrays.GLdoubleArray(params) ) -> None
glGetError(...)
glGetError(  ) -> GLenum
glGetFloatv( pname )
pyConverters: pname=None
cConverters: pname=None, params=<OpenGL.converters.SizedOutput object at 0x829fae4>
cResolvers: Not Used
storeValues: Not Used
returnValues:
oldStyleReturn(self, result, baseOperation, pyArgs, cArgs) method of SizedOutput instance
Retrieve cArgs[ self.index ]
Wrapping Operation: glGetFloatv( GLenum(pname), arrays.GLfloatArray(params) ) -> None
glGetFloatv( pname )
pyConverters: pname=None
cConverters: pname=None, params=<OpenGL.converters.SizedOutput object at 0x829fae4>
cResolvers: Not Used
storeValues: Not Used
returnValues:
oldStyleReturn(self, result, baseOperation, pyArgs, cArgs) method of SizedOutput instance
Retrieve cArgs[ self.index ]
Wrapping Operation: glGetFloatv( GLenum(pname), arrays.GLfloatArray(params) ) -> None
glGetHistogramParameterfv( target,pname )
pyConverters: target=None, pname=None
cConverters: target=None, pname=None, params=<OpenGL.converters.Output object at 0x8b7a0cc>
cResolvers: Not Used
storeValues: Not Used
returnValues:
oldStyleReturn(self, result, baseOperation, pyArgs, cArgs) method of Output instance
Retrieve cArgs[ self.index ]
Wrapping Operation: glGetHistogramParameterfv( GLenum(target), GLenum(pname), GLfloatArray(params) ) -> None
glGetHistogramParameteriv( target,pname )
pyConverters: target=None, pname=None
cConverters: target=None, pname=None, params=<OpenGL.converters.Output object at 0x8b7a144>
cResolvers: Not Used
storeValues: Not Used
returnValues:
oldStyleReturn(self, result, baseOperation, pyArgs, cArgs) method of Output instance
Retrieve cArgs[ self.index ]
Wrapping Operation: glGetHistogramParameteriv( GLenum(target), GLenum(pname), GLintArray(params) ) -> None
glGetIntegerv( pname )
pyConverters: pname=None
cConverters: pname=None, params=<OpenGL.converters.SizedOutput object at 0x829fb1c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
oldStyleReturn(self, result, baseOperation, pyArgs, cArgs) method of SizedOutput instance
Retrieve cArgs[ self.index ]
Wrapping Operation: glGetIntegerv( GLenum(pname), arrays.GLintArray(params) ) -> None
glGetIntegerv( pname )
pyConverters: pname=None
cConverters: pname=None, params=<OpenGL.converters.SizedOutput object at 0x829fb1c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
oldStyleReturn(self, result, baseOperation, pyArgs, cArgs) method of SizedOutput instance
Retrieve cArgs[ self.index ]
Wrapping Operation: glGetIntegerv( GLenum(pname), arrays.GLintArray(params) ) -> None
glGetLightfv( light,pname )
pyConverters: light=None, pname=None
cConverters: light=None, pname=None, params=<OpenGL.converters.SizedOutput object at 0x829fb54>
cResolvers: Not Used
storeValues: Not Used
returnValues:
oldStyleReturn(self, result, baseOperation, pyArgs, cArgs) method of SizedOutput instance
Retrieve cArgs[ self.index ]
Wrapping Operation: glGetLightfv( GLenum(light), GLenum(pname), arrays.GLfloatArray(params) ) -> None
glGetLightiv( light,pname )
pyConverters: light=None, pname=None
cConverters: light=None, pname=None, params=<OpenGL.converters.SizedOutput object at 0x829fb8c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
oldStyleReturn(self, result, baseOperation, pyArgs, cArgs) method of SizedOutput instance
Retrieve cArgs[ self.index ]
Wrapping Operation: glGetLightiv( GLenum(light), GLenum(pname), arrays.GLintArray(params) ) -> None
glGetMapdv( target,query,v )
pyConverters: target=None, query=None, v=<OpenGL.converters.CallFuncPyConverter object at 0x87f92ac>
cConverters: target=None, query=None, v=<OpenGL.converters.getPyArgsName object at 0x8b4cdec>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glGetMapdv( GLenum(target), GLenum(query), arrays.GLdoubleArray(v) ) -> None
glGetMapfv( target,query,v )
pyConverters: target=None, query=None, v=<OpenGL.converters.CallFuncPyConverter object at 0x87f92ec>
cConverters: target=None, query=None, v=<OpenGL.converters.getPyArgsName object at 0x8b4ce64>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glGetMapfv( GLenum(target), GLenum(query), arrays.GLfloatArray(v) ) -> None
glGetMapiv( target,query,v )
pyConverters: target=None, query=None, v=<OpenGL.converters.CallFuncPyConverter object at 0x87f93cc>
cConverters: target=None, query=None, v=<OpenGL.converters.getPyArgsName object at 0x8b4cedc>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glGetMapiv( GLenum(target), GLenum(query), arrays.GLintArray(v) ) -> None
glGetMaterialfv( face,pname )
pyConverters: face=None, pname=None
cConverters: face=None, pname=None, params=<OpenGL.converters.SizedOutput object at 0x829fbc4>
cResolvers: Not Used
storeValues: Not Used
returnValues:
oldStyleReturn(self, result, baseOperation, pyArgs, cArgs) method of SizedOutput instance
Retrieve cArgs[ self.index ]
Wrapping Operation: glGetMaterialfv( GLenum(face), GLenum(pname), arrays.GLfloatArray(params) ) -> None
glGetMaterialiv( face,pname )
pyConverters: face=None, pname=None
cConverters: face=None, pname=None, params=<OpenGL.converters.SizedOutput object at 0x829fbfc>
cResolvers: Not Used
storeValues: Not Used
returnValues:
oldStyleReturn(self, result, baseOperation, pyArgs, cArgs) method of SizedOutput instance
Retrieve cArgs[ self.index ]
Wrapping Operation: glGetMaterialiv( GLenum(face), GLenum(pname), arrays.GLintArray(params) ) -> None
glGetMinmaxParameterfv(...)
glGetMinmaxParameterfv( GLenum(target), GLenum(pname), GLfloatArray(params) ) -> None
glGetMinmaxParameteriv(...)
glGetMinmaxParameteriv( GLenum(target), GLenum(pname), GLintArray(params) ) -> None
glGetPixelMapfv( map )
pyConverters: map=None
cConverters: map=None, values=<OpenGL.converters.SizedOutput object at 0x829fc6c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
oldStyleReturn(self, result, baseOperation, pyArgs, cArgs) method of SizedOutput instance
Retrieve cArgs[ self.index ]
Wrapping Operation: glGetPixelMapfv( GLenum(map), arrays.GLfloatArray(values) ) -> None
glGetPixelMapuiv( map )
pyConverters: map=None
cConverters: map=None, values=<OpenGL.converters.SizedOutput object at 0x829fca4>
cResolvers: Not Used
storeValues: Not Used
returnValues:
oldStyleReturn(self, result, baseOperation, pyArgs, cArgs) method of SizedOutput instance
Retrieve cArgs[ self.index ]
Wrapping Operation: glGetPixelMapuiv( GLenum(map), arrays.GLuintArray(values) ) -> None
glGetPixelMapusv( map )
pyConverters: map=None
cConverters: map=None, values=<OpenGL.converters.SizedOutput object at 0x829fcdc>
cResolvers: Not Used
storeValues: Not Used
returnValues:
oldStyleReturn(self, result, baseOperation, pyArgs, cArgs) method of SizedOutput instance
Retrieve cArgs[ self.index ]
Wrapping Operation: glGetPixelMapusv( GLenum(map), arrays.GLushortArray(values) ) -> None
glGetPolygonStipple( )
pyConverters:
cConverters: mask=<OpenGL.converters.Output object at 0x8b669dc>
cResolvers: Not Used
storeValues: Not Used
returnValues:
oldStyleReturn(self, result, baseOperation, pyArgs, cArgs) method of Output instance
Retrieve cArgs[ self.index ]
Wrapping Operation: glGetPolygonStipple( arrays.GLubyteArray(mask) ) -> None
glGetPolygonStipple( )
pyConverters:
cConverters: mask=<OpenGL.converters.Output object at 0x8b669dc>
cResolvers: Not Used
storeValues: Not Used
returnValues:
oldStyleReturn(self, result, baseOperation, pyArgs, cArgs) method of Output instance
Retrieve cArgs[ self.index ]
Wrapping Operation: glGetPolygonStipple( arrays.GLubyteArray(mask) ) -> None
glGetProgramInfoLog(...)
glGetProgramInfoLog( GLuint(program), GLsizei(bufSize), GLsizeiArray(length), GLcharArray(infoLog) ) -> None
glGetProgramiv(...)
glGetProgramiv( GLuint(program), GLenum(pname), GLintArray(params) ) -> None
glGetQueryObjectiv(...)
glGetQueryObjectiv( GLuint(id), GLenum(pname), GLintArray(params) ) -> None
glGetQueryObjectuiv(...)
glGetQueryObjectuiv( GLuint(id), GLenum(pname), GLuintArray(params) ) -> None
glGetQueryiv(...)
glGetQueryiv( GLenum(target), GLenum(pname), GLintArray(params) ) -> None
glGetShaderInfoLog(...)
glGetShaderInfoLog( GLuint(shader), GLsizei(bufSize), GLsizeiArray(length), GLcharArray(infoLog) ) -> None
glGetShaderiv(...)
glGetShaderiv( GLuint(shader), GLenum(pname), GLintArray(params) ) -> None
glGetString(...)
glGetString( constant ) -> Current string value
glGetTexEnvfv( target,pname )
pyConverters: target=None, pname=None
cConverters: target=None, pname=None, params=<OpenGL.converters.SizedOutput object at 0x829fd14>
cResolvers: Not Used
storeValues: Not Used
returnValues:
oldStyleReturn(self, result, baseOperation, pyArgs, cArgs) method of SizedOutput instance
Retrieve cArgs[ self.index ]
Wrapping Operation: glGetTexEnvfv( GLenum(target), GLenum(pname), arrays.GLfloatArray(params) ) -> None
glGetTexEnviv( target,pname )
pyConverters: target=None, pname=None
cConverters: target=None, pname=None, params=<OpenGL.converters.SizedOutput object at 0x829fd4c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
oldStyleReturn(self, result, baseOperation, pyArgs, cArgs) method of SizedOutput instance
Retrieve cArgs[ self.index ]
Wrapping Operation: glGetTexEnviv( GLenum(target), GLenum(pname), arrays.GLintArray(params) ) -> None
glGetTexGendv( coord,pname )
pyConverters: coord=None, pname=None
cConverters: coord=None, pname=None, params=<OpenGL.converters.SizedOutput object at 0x829fd84>
cResolvers: Not Used
storeValues: Not Used
returnValues:
oldStyleReturn(self, result, baseOperation, pyArgs, cArgs) method of SizedOutput instance
Retrieve cArgs[ self.index ]
Wrapping Operation: glGetTexGendv( GLenum(coord), GLenum(pname), arrays.GLdoubleArray(params) ) -> None
glGetTexGenfv( coord,pname )
pyConverters: coord=None, pname=None
cConverters: coord=None, pname=None, params=<OpenGL.converters.SizedOutput object at 0x829fdbc>
cResolvers: Not Used
storeValues: Not Used
returnValues:
oldStyleReturn(self, result, baseOperation, pyArgs, cArgs) method of SizedOutput instance
Retrieve cArgs[ self.index ]
Wrapping Operation: glGetTexGenfv( GLenum(coord), GLenum(pname), arrays.GLfloatArray(params) ) -> None
glGetTexGeniv( coord,pname )
pyConverters: coord=None, pname=None
cConverters: coord=None, pname=None, params=<OpenGL.converters.SizedOutput object at 0x829fdf4>
cResolvers: Not Used
storeValues: Not Used
returnValues:
oldStyleReturn(self, result, baseOperation, pyArgs, cArgs) method of SizedOutput instance
Retrieve cArgs[ self.index ]
Wrapping Operation: glGetTexGeniv( GLenum(coord), GLenum(pname), arrays.GLintArray(params) ) -> None
glGetTexLevelParameterfv( target,level,pname )
pyConverters: target=None, level=None, pname=None
cConverters: target=None, level=None, pname=None, params=<OpenGL.converters.Output object at 0x8b66be4>
cResolvers: Not Used
storeValues: Not Used
returnValues:
oldStyleReturn(self, result, baseOperation, pyArgs, cArgs) method of Output instance
Retrieve cArgs[ self.index ]
Wrapping Operation: glGetTexLevelParameterfv( GLenum(target), GLint(level), GLenum(pname), arrays.GLfloatArray(params) ) -> None
glGetTexLevelParameteriv( target,level,pname )
pyConverters: target=None, level=None, pname=None
cConverters: target=None, level=None, pname=None, params=<OpenGL.converters.Output object at 0x8b66c5c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
oldStyleReturn(self, result, baseOperation, pyArgs, cArgs) method of Output instance
Retrieve cArgs[ self.index ]
Wrapping Operation: glGetTexLevelParameteriv( GLenum(target), GLint(level), GLenum(pname), arrays.GLintArray(params) ) -> None
glGetTexParameterfv( target,pname )
pyConverters: target=None, pname=None
cConverters: target=None, pname=None, params=<OpenGL.converters.SizedOutput object at 0x829fe2c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
oldStyleReturn(self, result, baseOperation, pyArgs, cArgs) method of SizedOutput instance
Retrieve cArgs[ self.index ]
Wrapping Operation: glGetTexParameterfv( GLenum(target), GLenum(pname), arrays.GLfloatArray(params) ) -> None
glGetTexParameteriv( target,pname )
pyConverters: target=None, pname=None
cConverters: target=None, pname=None, params=<OpenGL.converters.SizedOutput object at 0x829fe64>
cResolvers: Not Used
storeValues: Not Used
returnValues:
oldStyleReturn(self, result, baseOperation, pyArgs, cArgs) method of SizedOutput instance
Retrieve cArgs[ self.index ]
Wrapping Operation: glGetTexParameteriv( GLenum(target), GLenum(pname), arrays.GLintArray(params) ) -> None
glGetUniformLocation(...)
glGetUniformLocation( GLuint(program), GLcharArray(name) ) -> constants.GLint
glGetUniformfv(...)
glGetUniformfv( GLuint(program), GLint(location), GLfloatArray(params) ) -> None
glGetUniformiv(...)
glGetUniformiv( GLuint(program), GLint(location), GLintArray(params) ) -> None
glGetVertexAttribPointerv(...)
glGetVertexAttribPointerv( GLuint(index), GLenum(pname), POINTER(ctypes.c_void_p)(pointer) ) -> None
glGetVertexAttribdv(...)
glGetVertexAttribdv( GLuint(index), GLenum(pname), GLdoubleArray(params) ) -> None
glGetVertexAttribfv(...)
glGetVertexAttribfv( GLuint(index), GLenum(pname), GLfloatArray(params) ) -> None
glGetVertexAttribiv(...)
glGetVertexAttribiv( GLuint(index), GLenum(pname), GLintArray(params) ) -> None
glHint(...)
glHint( GLenum(target), GLenum(mode) ) -> None
glHistogram(...)
glHistogram( GLenum(target), GLsizei(width), GLenum(internalformat), GLboolean(sink) ) -> None
glIndexMask(...)
glIndexMask( GLuint(mask) ) -> None
glIndexPointer( type,stride,pointer )
pyConverters: type=None, stride=None, pointer=<OpenGL.arrays.arrayhelpers.AsArrayOfType object at 0x82a73cc>
cConverters: Not Used
cResolvers: type=None, stride=None, pointer=
voidDataPointer(cls, value) method of type instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object at 0x82a786c>
returnValues: <OpenGL.converters.returnPyArgument object at 0x8b5edc4>
Wrapping Operation: glIndexPointer( GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glIndexPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object at 0x863b46c>
cConverters: type=GL_BYTE, stride=0, pointer=<OpenGL.converters.getPyArgsName object at 0x87abfa4>
cResolvers: type=None, stride=None, pointer=
voidDataPointer(cls, value) method of _ctypes.PointerType instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object at 0x863b18c>
returnValues: <OpenGL.converters.returnPyArgument object at 0x8b5e02c>
Wrapping Operation: glIndexPointer( GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glIndexPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object at 0x87c13ac>
cConverters: type=GL_DOUBLE, stride=0, pointer=<OpenGL.converters.getPyArgsName object at 0x87abbbc>
cResolvers: type=None, stride=None, pointer=
voidDataPointer(cls, value) method of _ctypes.PointerType instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object at 0x87c186c>
returnValues: <OpenGL.converters.returnPyArgument object at 0x87abc0c>
Wrapping Operation: glIndexPointer( GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glIndexPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object at 0x87c1eec>
cConverters: type=GL_FLOAT, stride=0, pointer=<OpenGL.converters.getPyArgsName object at 0x87abc84>
cResolvers: type=None, stride=None, pointer=
voidDataPointer(cls, value) method of _ctypes.PointerType instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object at 0x87c1acc>
returnValues: <OpenGL.converters.returnPyArgument object at 0x87abcd4>
Wrapping Operation: glIndexPointer( GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glIndexPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object at 0x863bb6c>
cConverters: type=GL_INT, stride=0, pointer=<OpenGL.converters.getPyArgsName object at 0x87abd4c>
cResolvers: type=None, stride=None, pointer=
voidDataPointer(cls, value) method of _ctypes.PointerType instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object at 0x863b84c>
returnValues: <OpenGL.converters.returnPyArgument object at 0x87abd9c>
Wrapping Operation: glIndexPointer( GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glIndexPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object at 0x863b40c>
cConverters: type=GL_SHORT, stride=0, pointer=<OpenGL.converters.getPyArgsName object at 0x87abedc>
cResolvers: type=None, stride=None, pointer=
voidDataPointer(cls, value) method of _ctypes.PointerType instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object at 0x863bb8c>
returnValues: <OpenGL.converters.returnPyArgument object at 0x87abf2c>
Wrapping Operation: glIndexPointer( GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glIndexPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object at 0x863b1ec>
cConverters: type=GL_UNSIGNED_BYTE, stride=0, pointer=<OpenGL.converters.getPyArgsName object at 0x87abe14>
cResolvers: type=None, stride=None, pointer=
voidDataPointer(cls, value) method of _ctypes.PointerType instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object at 0x863b44c>
returnValues: <OpenGL.converters.returnPyArgument object at 0x87abe64>
Wrapping Operation: glIndexPointer( GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glIndexd(...)
glIndexd( GLdouble(c) ) -> None
glIndexdv( c )
pyConverters: c=
asArraySize(incoming, function, args)
cConverters: c=<OpenGL.converters.getPyArgsName object at 0x87a7464>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glIndexdv( arrays.GLdoubleArray(c) ) -> None
glIndexf(...)
glIndexf( GLfloat(c) ) -> None
glIndexfv( c )
pyConverters: c=
asArraySize(incoming, function, args)
cConverters: c=<OpenGL.converters.getPyArgsName object at 0x87a7504>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glIndexfv( arrays.GLfloatArray(c) ) -> None
glIndexi(...)
glIndexi( GLint(c) ) -> None
glIndexiv( c )
pyConverters: c=<OpenGL.converters.CallFuncPyConverter object at 0x82acf8c>
cConverters: c=<OpenGL.converters.getPyArgsName object at 0x8b4f784>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glIndexiv( arrays.GLintArray(c) ) -> None
glIndexs(...)
glIndexs( GLshort(c) ) -> None
glIndexsv( c )
pyConverters: c=
asArraySize(incoming, function, args)
cConverters: c=<OpenGL.converters.getPyArgsName object at 0x87a73c4>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glIndexsv( arrays.GLshortArray(c) ) -> None
glIndexub(...)
glIndexub( GLubyte(c) ) -> None
glIndexubv( c )
pyConverters: c=
asArraySize(incoming, function, args)
cConverters: c=<OpenGL.converters.getPyArgsName object at 0x87a75a4>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glIndexubv( arrays.GLubyteArray(c) ) -> None
glInitNames(...)
glInitNames(  ) -> None
glInterleavedArrays = <OpenGL.wrapper.glInterleavedArrays object at 0x82a710c>
glIsBuffer(...)
glIsBuffer( GLuint(buffer) ) -> constants.GLboolean
glIsEnabled(...)
glIsEnabled( GLenum(cap) ) -> GLboolean
glIsList(...)
glIsList( GLuint(list) ) -> GLboolean
glIsProgram(...)
glIsProgram( GLuint(program) ) -> constants.GLboolean
glIsQuery(...)
glIsQuery( GLuint(id) ) -> constants.GLboolean
glIsShader(...)
glIsShader( GLuint(shader) ) -> constants.GLboolean
glIsTexture(...)
glIsTexture( GLuint(texture) ) -> GLboolean
glLightfv( light,pname,params )
pyConverters: light=None, pname=None, params=<OpenGL.converters.CallFuncPyConverter object at 0x82ac6ac>
cConverters: light=None, pname=None, params=<OpenGL.converters.getPyArgsName object at 0x8b4f9dc>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glLightfv( GLenum(light), GLenum(pname), arrays.GLfloatArray(params) ) -> None
glLightModelf(...)
glLightModelf( GLenum(pname), GLfloat(param) ) -> None
glLightModelfv( pname,params )
pyConverters: pname=None, params=<OpenGL.converters.CallFuncPyConverter object at 0x82ac74c>
cConverters: pname=None, params=<OpenGL.converters.getPyArgsName object at 0x8b4f8ec>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glLightModelfv( GLenum(pname), arrays.GLfloatArray(params) ) -> None
glLightModeli(...)
glLightModeli( GLenum(pname), GLint(param) ) -> None
glLightModeliv( pname,params )
pyConverters: pname=None, params=<OpenGL.converters.CallFuncPyConverter object at 0x82ac98c>
cConverters: pname=None, params=<OpenGL.converters.getPyArgsName object at 0x8b4f964>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glLightModeliv( GLenum(pname), arrays.GLintArray(params) ) -> None
glLightf(...)
glLightf( GLenum(light), GLenum(pname), GLfloat(param) ) -> None
glLightfv( light,pname,params )
pyConverters: light=None, pname=None, params=<OpenGL.converters.CallFuncPyConverter object at 0x82ac6ac>
cConverters: light=None, pname=None, params=<OpenGL.converters.getPyArgsName object at 0x8b4f9dc>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glLightfv( GLenum(light), GLenum(pname), arrays.GLfloatArray(params) ) -> None
glLighti(...)
glLighti( GLenum(light), GLenum(pname), GLint(param) ) -> None
glLightiv( light,pname,params )
pyConverters: light=None, pname=None, params=<OpenGL.converters.CallFuncPyConverter object at 0x82acf2c>
cConverters: light=None, pname=None, params=<OpenGL.converters.getPyArgsName object at 0x8b4fa54>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glLightiv( GLenum(light), GLenum(pname), arrays.GLintArray(params) ) -> None
glLineStipple(...)
glLineStipple( GLint(factor), GLushort(pattern) ) -> None
glLineWidth(...)
glLineWidth( GLfloat(width) ) -> None
glLinkProgram(...)
glLinkProgram( GLuint(program) ) -> None
glListBase(...)
glListBase( GLuint(base) ) -> None
glLoadIdentity(...)
glLoadIdentity(  ) -> None
glLoadMatrixd( m )
pyConverters: m=
asArraySize(incoming, function, args)
cConverters: m=<OpenGL.converters.getPyArgsName object at 0x8b4facc>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glLoadMatrixd( arrays.GLdoubleArray(m) ) -> None
glLoadMatrixf( m )
pyConverters: m=
asArraySize(incoming, function, args)
cConverters: m=<OpenGL.converters.getPyArgsName object at 0x8b4fb6c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glLoadMatrixf( arrays.GLfloatArray(m) ) -> None
glLoadName(...)
glLoadName( GLuint(name) ) -> None
glLoadTransposeMatrixd( m )
pyConverters: m=
asArraySize(incoming, function, args)
cConverters: m=<OpenGL.converters.getPyArgsName object at 0x878243c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glLoadTransposeMatrixd( GLdoubleArray(m) ) -> None
glLoadTransposeMatrixf( m )
pyConverters: m=
asArraySize(incoming, function, args)
cConverters: m=<OpenGL.converters.getPyArgsName object at 0x878257c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glLoadTransposeMatrixf( GLfloatArray(m) ) -> None
glLogicOp(...)
glLogicOp( GLenum(opcode) ) -> None
glMapBuffer(...)
glMapBuffer( GLenum(target), GLenum(access) ) -> ctypes.c_void_p
glMapGrid1d(...)
glMapGrid1d( GLint(un), GLdouble(u1), GLdouble(u2) ) -> None
glMapGrid1f(...)
glMapGrid1f( GLint(un), GLfloat(u1), GLfloat(u2) ) -> None
glMapGrid2d(...)
glMapGrid2d( GLint(un), GLdouble(u1), GLdouble(u2), GLint(vn), GLdouble(v1), GLdouble(v2) ) -> None
glMapGrid2f(...)
glMapGrid2f( GLint(un), GLfloat(u1), GLfloat(u2), GLint(vn), GLfloat(v1), GLfloat(v2) ) -> None
glMaterialf(...)
glMaterialf( GLenum(face), GLenum(pname), GLfloat(param) ) -> None
glMaterialfv( face,pname,params )
pyConverters: face=None, pname=None, params=<OpenGL.converters.CallFuncPyConverter object at 0x824cf6c>
cConverters: face=None, pname=None, params=<OpenGL.converters.getPyArgsName object at 0x8b4fdec>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glMaterialfv( GLenum(face), GLenum(pname), arrays.GLfloatArray(params) ) -> None
glMateriali(...)
glMateriali( GLenum(face), GLenum(pname), GLint(param) ) -> None
glMaterialiv( face,pname,params )
pyConverters: face=None, pname=None, params=<OpenGL.converters.CallFuncPyConverter object at 0x824cf0c>
cConverters: face=None, pname=None, params=<OpenGL.converters.getPyArgsName object at 0x8b4fe64>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glMaterialiv( GLenum(face), GLenum(pname), arrays.GLintArray(params) ) -> None
glMatrixMode(...)
glMatrixMode( GLenum(mode) ) -> None
glMinmax(...)
glMinmax( GLenum(target), GLenum(internalformat), GLboolean(sink) ) -> None
glMultMatrixd( m )
pyConverters: m=
asArraySize(incoming, function, args)
cConverters: m=<OpenGL.converters.getPyArgsName object at 0x8b4fedc>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glMultMatrixd( arrays.GLdoubleArray(m) ) -> None
glMultMatrixf( m )
pyConverters: m=
asArraySize(incoming, function, args)
cConverters: m=<OpenGL.converters.getPyArgsName object at 0x8b4ff7c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glMultMatrixf( arrays.GLfloatArray(m) ) -> None
glMultTransposeMatrixd( m )
pyConverters: m=
asArraySize(incoming, function, args)
cConverters: m=<OpenGL.converters.getPyArgsName object at 0x87824dc>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glMultTransposeMatrixd( GLdoubleArray(m) ) -> None
glMultTransposeMatrixf( m )
pyConverters: m=
asArraySize(incoming, function, args)
cConverters: m=<OpenGL.converters.getPyArgsName object at 0x878261c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glMultTransposeMatrixf( GLfloatArray(m) ) -> None
glMultiDrawArrays(...)
glMultiDrawArrays( GLenum(mode), GLintArray(first), GLsizeiArray(count), GLsizei(primcount) ) -> None
glMultiDrawElements(...)
glMultiDrawElements( GLenum(mode), GLsizeiArray(count), GLenum(type), POINTER(ctypes.c_void_p)(indices), GLsizei(primcount) ) -> None
glMultiTexCoord1d(...)
glMultiTexCoord1d( GLenum(target), GLdouble(s) ) -> None
glMultiTexCoord1dv( target,v )
pyConverters: target=None, v=
asArraySize(incoming, function, args)
cConverters: target=None, v=<OpenGL.converters.getPyArgsName object at 0x851ca04>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glMultiTexCoord1dv( GLenum(target), GLdoubleArray(v) ) -> None
glMultiTexCoord1f(...)
glMultiTexCoord1f( GLenum(target), GLfloat(s) ) -> None
glMultiTexCoord1fv( target,v )
pyConverters: target=None, v=
asArraySize(incoming, function, args)
cConverters: target=None, v=<OpenGL.converters.getPyArgsName object at 0x851cc84>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glMultiTexCoord1fv( GLenum(target), GLfloatArray(v) ) -> None
glMultiTexCoord1i(...)
glMultiTexCoord1i( GLenum(target), GLint(s) ) -> None
glMultiTexCoord1iv( target,v )
pyConverters: target=None, v=
asArraySize(incoming, function, args)
cConverters: target=None, v=<OpenGL.converters.getPyArgsName object at 0x851cf04>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glMultiTexCoord1iv( GLenum(target), GLintArray(v) ) -> None
glMultiTexCoord1s(...)
glMultiTexCoord1s( GLenum(target), GLshort(s) ) -> None
glMultiTexCoord1sv( target,v )
pyConverters: target=None, v=
asArraySize(incoming, function, args)
cConverters: target=None, v=<OpenGL.converters.getPyArgsName object at 0x87821bc>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glMultiTexCoord1sv( GLenum(target), GLshortArray(v) ) -> None
glMultiTexCoord2d(...)
glMultiTexCoord2d( GLenum(target), GLdouble(s), GLdouble(t) ) -> None
glMultiTexCoord2dv( target,v )
pyConverters: target=None, v=
asArraySize(incoming, function, args)
cConverters: target=None, v=<OpenGL.converters.getPyArgsName object at 0x851caa4>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glMultiTexCoord2dv( GLenum(target), GLdoubleArray(v) ) -> None
glMultiTexCoord2f(...)
glMultiTexCoord2f( GLenum(target), GLfloat(s), GLfloat(t) ) -> None
glMultiTexCoord2fv( target,v )
pyConverters: target=None, v=
asArraySize(incoming, function, args)
cConverters: target=None, v=<OpenGL.converters.getPyArgsName object at 0x851cd24>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glMultiTexCoord2fv( GLenum(target), GLfloatArray(v) ) -> None
glMultiTexCoord2i(...)
glMultiTexCoord2i( GLenum(target), GLint(s), GLint(t) ) -> None
glMultiTexCoord2iv( target,v )
pyConverters: target=None, v=
asArraySize(incoming, function, args)
cConverters: target=None, v=<OpenGL.converters.getPyArgsName object at 0x851cfa4>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glMultiTexCoord2iv( GLenum(target), GLintArray(v) ) -> None
glMultiTexCoord2s(...)
glMultiTexCoord2s( GLenum(target), GLshort(s), GLshort(t) ) -> None
glMultiTexCoord2sv( target,v )
pyConverters: target=None, v=
asArraySize(incoming, function, args)
cConverters: target=None, v=<OpenGL.converters.getPyArgsName object at 0x878225c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glMultiTexCoord2sv( GLenum(target), GLshortArray(v) ) -> None
glMultiTexCoord3d(...)
glMultiTexCoord3d( GLenum(target), GLdouble(s), GLdouble(t), GLdouble(r) ) -> None
glMultiTexCoord3dv( target,v )
pyConverters: target=None, v=
asArraySize(incoming, function, args)
cConverters: target=None, v=<OpenGL.converters.getPyArgsName object at 0x851cb44>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glMultiTexCoord3dv( GLenum(target), GLdoubleArray(v) ) -> None
glMultiTexCoord3f(...)
glMultiTexCoord3f( GLenum(target), GLfloat(s), GLfloat(t), GLfloat(r) ) -> None
glMultiTexCoord3fv( target,v )
pyConverters: target=None, v=
asArraySize(incoming, function, args)
cConverters: target=None, v=<OpenGL.converters.getPyArgsName object at 0x851cdc4>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glMultiTexCoord3fv( GLenum(target), GLfloatArray(v) ) -> None
glMultiTexCoord3i(...)
glMultiTexCoord3i( GLenum(target), GLint(s), GLint(t), GLint(r) ) -> None
glMultiTexCoord3iv( target,v )
pyConverters: target=None, v=
asArraySize(incoming, function, args)
cConverters: target=None, v=<OpenGL.converters.getPyArgsName object at 0x878207c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glMultiTexCoord3iv( GLenum(target), GLintArray(v) ) -> None
glMultiTexCoord3s(...)
glMultiTexCoord3s( GLenum(target), GLshort(s), GLshort(t), GLshort(r) ) -> None
glMultiTexCoord3sv( target,v )
pyConverters: target=None, v=
asArraySize(incoming, function, args)
cConverters: target=None, v=<OpenGL.converters.getPyArgsName object at 0x87822fc>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glMultiTexCoord3sv( GLenum(target), GLshortArray(v) ) -> None
glMultiTexCoord4d(...)
glMultiTexCoord4d( GLenum(target), GLdouble(s), GLdouble(t), GLdouble(r), GLdouble(q) ) -> None
glMultiTexCoord4dv( target,v )
pyConverters: target=None, v=
asArraySize(incoming, function, args)
cConverters: target=None, v=<OpenGL.converters.getPyArgsName object at 0x851cbe4>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glMultiTexCoord4dv( GLenum(target), GLdoubleArray(v) ) -> None
glMultiTexCoord4f(...)
glMultiTexCoord4f( GLenum(target), GLfloat(s), GLfloat(t), GLfloat(r), GLfloat(q) ) -> None
glMultiTexCoord4fv( target,v )
pyConverters: target=None, v=
asArraySize(incoming, function, args)
cConverters: target=None, v=<OpenGL.converters.getPyArgsName object at 0x851ce64>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glMultiTexCoord4fv( GLenum(target), GLfloatArray(v) ) -> None
glMultiTexCoord4i(...)
glMultiTexCoord4i( GLenum(target), GLint(s), GLint(t), GLint(r), GLint(q) ) -> None
glMultiTexCoord4iv( target,v )
pyConverters: target=None, v=
asArraySize(incoming, function, args)
cConverters: target=None, v=<OpenGL.converters.getPyArgsName object at 0x878211c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glMultiTexCoord4iv( GLenum(target), GLintArray(v) ) -> None
glMultiTexCoord4s(...)
glMultiTexCoord4s( GLenum(target), GLshort(s), GLshort(t), GLshort(r), GLshort(q) ) -> None
glMultiTexCoord4sv( target,v )
pyConverters: target=None, v=
asArraySize(incoming, function, args)
cConverters: target=None, v=<OpenGL.converters.getPyArgsName object at 0x878239c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glMultiTexCoord4sv( GLenum(target), GLshortArray(v) ) -> None
glNewList(...)
glNewList( GLuint(list), GLenum(mode) ) -> None
glNormal = glNormal3d(...)
glNormal3d( GLdouble(nx), GLdouble(ny), GLdouble(nz) ) -> None
glNormal3b(...)
glNormal3b( GLbyte(nx), GLbyte(ny), GLbyte(nz) ) -> None
glNormal3bv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b53054>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glNormal3bv( arrays.GLbyteArray(v) ) -> None
glNormal3d(...)
glNormal3d( GLdouble(nx), GLdouble(ny), GLdouble(nz) ) -> None
glNormal3dv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b530f4>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glNormal3dv( arrays.GLdoubleArray(v) ) -> None
glNormal3f(...)
glNormal3f( GLfloat(nx), GLfloat(ny), GLfloat(nz) ) -> None
glNormal3fv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b53194>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glNormal3fv( arrays.GLfloatArray(v) ) -> None
glNormal3i(...)
glNormal3i( GLint(nx), GLint(ny), GLint(nz) ) -> None
glNormal3iv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b53234>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glNormal3iv( arrays.GLintArray(v) ) -> None
glNormal3s(...)
glNormal3s( GLshort(nx), GLshort(ny), GLshort(nz) ) -> None
glNormal3sv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b532d4>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glNormal3sv( arrays.GLshortArray(v) ) -> None
glNormalPointer( type,stride,pointer )
pyConverters: type=None, stride=None, pointer=<OpenGL.arrays.arrayhelpers.AsArrayOfType object at 0x82a7bac>
cConverters: Not Used
cResolvers: type=None, stride=None, pointer=
voidDataPointer(cls, value) method of type instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object at 0x82a75ac>
returnValues: <OpenGL.converters.returnPyArgument object at 0x8b5ed4c>
Wrapping Operation: glNormalPointer( GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glNormalPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object at 0x863b78c>
cConverters: type=GL_BYTE, stride=0, pointer=<OpenGL.converters.getPyArgsName object at 0x8b5e2fc>
cResolvers: type=None, stride=None, pointer=
voidDataPointer(cls, value) method of _ctypes.PointerType instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object at 0x863b22c>
returnValues: <OpenGL.converters.returnPyArgument object at 0x8b5e34c>
Wrapping Operation: glNormalPointer( GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glNormalPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object at 0x863bd8c>
cConverters: type=GL_DOUBLE, stride=0, pointer=<OpenGL.converters.getPyArgsName object at 0x8b5e0a4>
cResolvers: type=None, stride=None, pointer=
voidDataPointer(cls, value) method of _ctypes.PointerType instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object at 0x863beac>
returnValues: <OpenGL.converters.returnPyArgument object at 0x8b5e0f4>
Wrapping Operation: glNormalPointer( GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glNormalPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object at 0x863b9ac>
cConverters: type=GL_FLOAT, stride=0, pointer=<OpenGL.converters.getPyArgsName object at 0x8b5e16c>
cResolvers: type=None, stride=None, pointer=
voidDataPointer(cls, value) method of _ctypes.PointerType instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object at 0x863b42c>
returnValues: <OpenGL.converters.returnPyArgument object at 0x8b5e1bc>
Wrapping Operation: glNormalPointer( GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glNormalPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object at 0x863b30c>
cConverters: type=GL_INT, stride=0, pointer=<OpenGL.converters.getPyArgsName object at 0x8b5e234>
cResolvers: type=None, stride=None, pointer=
voidDataPointer(cls, value) method of _ctypes.PointerType instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object at 0x863bccc>
returnValues: <OpenGL.converters.returnPyArgument object at 0x8b5e284>
Wrapping Operation: glNormalPointer( GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glNormalPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object at 0x863b34c>
cConverters: type=GL_SHORT, stride=0, pointer=<OpenGL.converters.getPyArgsName object at 0x8b5e3c4>
cResolvers: type=None, stride=None, pointer=
voidDataPointer(cls, value) method of _ctypes.PointerType instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object at 0x863bfec>
returnValues: <OpenGL.converters.returnPyArgument object at 0x8b5e414>
Wrapping Operation: glNormalPointer( GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glOrtho(...)
glOrtho( GLdouble(left), GLdouble(right), GLdouble(bottom), GLdouble(top), GLdouble(zNear), GLdouble(zFar) ) -> None
glPassThrough(...)
glPassThrough( GLfloat(token) ) -> None
glPixelMapfv( map,mapsize,values )
pyConverters: map=None, mapsize=None, values=<OpenGL.converters.CallFuncPyConverter object at 0x824c28c>
cConverters: map=None, mapsize=None, values=<OpenGL.converters.getPyArgsName object at 0x8b53374>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glPixelMapfv( GLenum(map), GLsizei(mapsize), arrays.GLfloatArray(values) ) -> None
glPixelMapuiv( map,mapsize,values )
pyConverters: map=None, mapsize=None, values=<OpenGL.converters.CallFuncPyConverter object at 0x824c9ac>
cConverters: map=None, mapsize=None, values=<OpenGL.converters.getPyArgsName object at 0x8b533ec>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glPixelMapuiv( GLenum(map), GLsizei(mapsize), arrays.GLuintArray(values) ) -> None
glPixelMapusv( map,mapsize,values )
pyConverters: map=None, mapsize=None, values=<OpenGL.converters.CallFuncPyConverter object at 0x82b21cc>
cConverters: map=None, mapsize=None, values=<OpenGL.converters.getPyArgsName object at 0x8b53464>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glPixelMapusv( GLenum(map), GLsizei(mapsize), arrays.GLushortArray(values) ) -> None
glPixelStoref(...)
glPixelStoref( GLenum(pname), GLfloat(param) ) -> None
glPixelStorei(...)
glPixelStorei( GLenum(pname), GLint(param) ) -> None
glPixelTransferf(...)
glPixelTransferf( GLenum(pname), GLfloat(param) ) -> None
glPixelTransferi(...)
glPixelTransferi( GLenum(pname), GLint(param) ) -> None
glPixelZoom(...)
glPixelZoom( GLfloat(xfactor), GLfloat(yfactor) ) -> None
glPointParameterf(...)
glPointParameterf( GLenum(pname), GLfloat(param) ) -> None
glPointParameterfv(...)
glPointParameterfv( GLenum(pname), GLfloatArray(params) ) -> None
glPointParameteri(...)
glPointParameteri( GLenum(pname), GLint(param) ) -> None
glPointParameteriv(...)
glPointParameteriv( GLenum(pname), GLintArray(params) ) -> None
glPointSize(...)
glPointSize( GLfloat(size) ) -> None
glPolygonMode(...)
glPolygonMode( GLenum(face), GLenum(mode) ) -> None
glPolygonOffset(...)
glPolygonOffset( GLfloat(factor), GLfloat(units) ) -> None
glPolygonStipple( mask )
pyConverters: mask=<OpenGL.converters.CallFuncPyConverter object at 0x82b232c>
cConverters: mask=<OpenGL.converters.getPyArgsName object at 0x8b534dc>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glPolygonStipple( arrays.GLubyteArray(mask) ) -> None
glPopAttrib(...)
glPopAttrib(  ) -> None
glPopClientAttrib(...)
glPopClientAttrib(  ) -> None
glPopMatrix(...)
glPopMatrix(  ) -> None
glPopName(...)
glPopName(  ) -> None
glPrioritizeTextures( n,textures,priorities )
pyConverters: n=None, textures=<OpenGL.converters.CallFuncPyConverter object at 0x82b2ccc>, priorities=<OpenGL.converters.CallFuncPyConverter object at 0x82b262c>
cConverters: n=None, textures=<OpenGL.converters.getPyArgsName object at 0x8b53554>, priorities=<OpenGL.converters.getPyArgsName object at 0x8b535a4>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glPrioritizeTextures( GLsizei(n), arrays.GLuintArray(textures), arrays.GLclampfArray(priorities) ) -> None
glPushAttrib(...)
glPushAttrib( GLbitfield(mask) ) -> None
glPushClientAttrib(...)
glPushClientAttrib( GLbitfield(mask) ) -> None
glPushMatrix(...)
glPushMatrix(  ) -> None
glPushName(...)
glPushName( GLuint(name) ) -> None
glRasterPos2d(...)
glRasterPos2d( GLdouble(x), GLdouble(y) ) -> None
glRasterPos2dv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b5361c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glRasterPos2dv( arrays.GLdoubleArray(v) ) -> None
glRasterPos2f(...)
glRasterPos2f( GLfloat(x), GLfloat(y) ) -> None
glRasterPos2fv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b536bc>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glRasterPos2fv( arrays.GLfloatArray(v) ) -> None
glRasterPos2i(...)
glRasterPos2i( GLint(x), GLint(y) ) -> None
glRasterPos2iv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b5375c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glRasterPos2iv( arrays.GLintArray(v) ) -> None
glRasterPos2s(...)
glRasterPos2s( GLshort(x), GLshort(y) ) -> None
glRasterPos2sv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b537fc>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glRasterPos2sv( arrays.GLshortArray(v) ) -> None
glRasterPos3d(...)
glRasterPos3d( GLdouble(x), GLdouble(y), GLdouble(z) ) -> None
glRasterPos3dv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b5389c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glRasterPos3dv( arrays.GLdoubleArray(v) ) -> None
glRasterPos3f(...)
glRasterPos3f( GLfloat(x), GLfloat(y), GLfloat(z) ) -> None
glRasterPos3fv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b5393c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glRasterPos3fv( arrays.GLfloatArray(v) ) -> None
glRasterPos3i(...)
glRasterPos3i( GLint(x), GLint(y), GLint(z) ) -> None
glRasterPos3iv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b539dc>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glRasterPos3iv( arrays.GLintArray(v) ) -> None
glRasterPos3s(...)
glRasterPos3s( GLshort(x), GLshort(y), GLshort(z) ) -> None
glRasterPos3sv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b53a7c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glRasterPos3sv( arrays.GLshortArray(v) ) -> None
glRasterPos4d(...)
glRasterPos4d( GLdouble(x), GLdouble(y), GLdouble(z), GLdouble(w) ) -> None
glRasterPos4dv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b53b1c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glRasterPos4dv( arrays.GLdoubleArray(v) ) -> None
glRasterPos4f(...)
glRasterPos4f( GLfloat(x), GLfloat(y), GLfloat(z), GLfloat(w) ) -> None
glRasterPos4fv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b53bbc>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glRasterPos4fv( arrays.GLfloatArray(v) ) -> None
glRasterPos4i(...)
glRasterPos4i( GLint(x), GLint(y), GLint(z), GLint(w) ) -> None
glRasterPos4iv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b53c5c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glRasterPos4iv( arrays.GLintArray(v) ) -> None
glRasterPos4s(...)
glRasterPos4s( GLshort(x), GLshort(y), GLshort(z), GLshort(w) ) -> None
glRasterPos4sv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b53cfc>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glRasterPos4sv( arrays.GLshortArray(v) ) -> None
glReadBuffer(...)
glReadBuffer( GLenum(mode) ) -> None
glRectd(...)
glRectd( GLdouble(x1), GLdouble(y1), GLdouble(x2), GLdouble(y2) ) -> None
glRectdv( v1,v2 )
pyConverters: v1=<OpenGL.converters.CallFuncPyConverter object at 0x82a1bcc>, v2=<OpenGL.converters.CallFuncPyConverter object at 0x82a1cac>
cConverters: v1=<OpenGL.converters.getPyArgsName object at 0x8b53d9c>, v2=<OpenGL.converters.getPyArgsName object at 0x8b53dec>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glRectdv( arrays.GLdoubleArray(v1), arrays.GLdoubleArray(v2) ) -> None
glRectf(...)
glRectf( GLfloat(x1), GLfloat(y1), GLfloat(x2), GLfloat(y2) ) -> None
glRectfv( v1,v2 )
pyConverters: v1=
asArraySize(incoming, function, args)
, v2=
asArraySize(incoming, function, args)
cConverters: v1=<OpenGL.converters.getPyArgsName object at 0x8b6fedc>, v2=<OpenGL.converters.getPyArgsName object at 0x8b6ff54>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glRectfv( arrays.GLfloatArray(v1), arrays.GLfloatArray(v2) ) -> None
glRecti(...)
glRecti( GLint(x1), GLint(y1), GLint(x2), GLint(y2) ) -> None
glRectiv( v1,v2 )
pyConverters: v1=
asArraySize(incoming, function, args)
, v2=
asArraySize(incoming, function, args)
cConverters: v1=<OpenGL.converters.getPyArgsName object at 0x87a702c>, v2=<OpenGL.converters.getPyArgsName object at 0x87a720c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glRectiv( arrays.GLintArray(v1), arrays.GLintArray(v2) ) -> None
glRects(...)
glRects( GLshort(x1), GLshort(y1), GLshort(x2), GLshort(y2) ) -> None
glRectsv( v1,v2 )
pyConverters: v1=
asArraySize(incoming, function, args)
, v2=
asArraySize(incoming, function, args)
cConverters: v1=<OpenGL.converters.getPyArgsName object at 0x87a72ac>, v2=<OpenGL.converters.getPyArgsName object at 0x87a7324>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glRectsv( arrays.GLshortArray(v1), arrays.GLshortArray(v2) ) -> None
glResetHistogram(...)
glResetHistogram( GLenum(target) ) -> None
glResetMinmax(...)
glResetMinmax( GLenum(target) ) -> None
glRotate = glRotated(...)
glRotated( GLdouble(angle), GLdouble(x), GLdouble(y), GLdouble(z) ) -> None
glRotated(...)
glRotated( GLdouble(angle), GLdouble(x), GLdouble(y), GLdouble(z) ) -> None
glRotatef(...)
glRotatef( GLfloat(angle), GLfloat(x), GLfloat(y), GLfloat(z) ) -> None
glSampleCoverage(...)
glSampleCoverage( GLclampf(value), GLboolean(invert) ) -> None
glScale = glScaled(...)
glScaled( GLdouble(x), GLdouble(y), GLdouble(z) ) -> None
glScaled(...)
glScaled( GLdouble(x), GLdouble(y), GLdouble(z) ) -> None
glScalef(...)
glScalef( GLfloat(x), GLfloat(y), GLfloat(z) ) -> None
glScissor(...)
glScissor( GLint(x), GLint(y), GLsizei(width), GLsizei(height) ) -> None
glSecondaryColor3b(...)
glSecondaryColor3b( GLbyte(red), GLbyte(green), GLbyte(blue) ) -> None
glSecondaryColor3bv(...)
glSecondaryColor3bv( GLbyteArray(v) ) -> None
glSecondaryColor3d(...)
glSecondaryColor3d( GLdouble(red), GLdouble(green), GLdouble(blue) ) -> None
glSecondaryColor3dv(...)
glSecondaryColor3dv( GLdoubleArray(v) ) -> None
glSecondaryColor3f(...)
glSecondaryColor3f( GLfloat(red), GLfloat(green), GLfloat(blue) ) -> None
glSecondaryColor3fv(...)
glSecondaryColor3fv( GLfloatArray(v) ) -> None
glSecondaryColor3i(...)
glSecondaryColor3i( GLint(red), GLint(green), GLint(blue) ) -> None
glSecondaryColor3iv(...)
glSecondaryColor3iv( GLintArray(v) ) -> None
glSecondaryColor3s(...)
glSecondaryColor3s( GLshort(red), GLshort(green), GLshort(blue) ) -> None
glSecondaryColor3sv(...)
glSecondaryColor3sv( GLshortArray(v) ) -> None
glSecondaryColor3ub(...)
glSecondaryColor3ub( GLubyte(red), GLubyte(green), GLubyte(blue) ) -> None
glSecondaryColor3ubv(...)
glSecondaryColor3ubv( GLubyteArray(v) ) -> None
glSecondaryColor3ui(...)
glSecondaryColor3ui( GLuint(red), GLuint(green), GLuint(blue) ) -> None
glSecondaryColor3uiv(...)
glSecondaryColor3uiv( GLuintArray(v) ) -> None
glSecondaryColor3us(...)
glSecondaryColor3us( GLushort(red), GLushort(green), GLushort(blue) ) -> None
glSecondaryColor3usv(...)
glSecondaryColor3usv( GLushortArray(v) ) -> None
glSecondaryColorPointer(...)
glSecondaryColorPointer( GLint(size), GLenum(type), GLsizei(stride), c_void_p(pointer) ) -> None
glSeparableFilter2D( target,internalformat,width,height,format,type,row,column )
pyConverters: target=None, internalformat=None, width=
asIntConverter(value, *args)
, height=
asIntConverter(value, *args)
, format=None, type=None, row=<OpenGL.GL.images.ImageInputConverter object at 0x827fe6c>, column=<OpenGL.GL.images.ImageInputConverter object at 0x827ff8c>
cConverters: Not Used
cResolvers: target=None, internalformat=None, width=None, height=None, format=None, type=None, row=
cResolver(self, array) method of ImageInputConverter instance
, column=
cResolver(self, array) method of ImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glSeparableFilter2D( GLenum(target), GLenum(internalformat), GLsizei(width), GLsizei(height), GLenum(format), GLenum(type), c_void_p(row), c_void_p(column) ) -> None
glShadeModel(...)
glShadeModel( GLenum(mode) ) -> None
glShaderSource( shaderObj,string )
pyConverters: shaderObj=None, string=
stringArray(self, arg, baseOperation, args) method of StringLengths instance
Create basic array-of-strings object from pyArg
cConverters: shaderObj=None, count=
totalCount(self, pyArgs, index, baseOperation) method of StringLengths instance
Get array of length integers for string contents
, string=None, length=<OpenGL.converters.StringLengths object at 0x829e7cc>
cResolvers: shaderObj=None, count=None, string=
stringArrayForC(self, strings) method of StringLengths instance
Create a ctypes pointer to char-pointer set
, length=None
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glShaderSource( GLhandle(shaderObj), str( string) ) -> None
glStencilFunc(...)
glStencilFunc( GLenum(func), GLint(ref), GLuint(mask) ) -> None
glStencilFuncSeparate(...)
glStencilFuncSeparate( GLenum(frontfunc), GLenum(backfunc), GLint(ref), GLuint(mask) ) -> None
glStencilMask(...)
glStencilMask( GLuint(mask) ) -> None
glStencilMaskSeparate(...)
glStencilMaskSeparate( GLenum(face), GLuint(mask) ) -> None
glStencilOp(...)
glStencilOp( GLenum(fail), GLenum(zfail), GLenum(zpass) ) -> None
glStencilOpSeparate(...)
glStencilOpSeparate( GLenum(face), GLenum(sfail), GLenum(dpfail), GLenum(dppass) ) -> None
glTexCoord = glTexCoord2d(...)
glTexCoord2d( GLdouble(s), GLdouble(t) ) -> None
glTexCoord1d(...)
glTexCoord1d( GLdouble(s) ) -> None
glTexCoord1dv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b5716c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glTexCoord1dv( arrays.GLdoubleArray(v) ) -> None
glTexCoord1f(...)
glTexCoord1f( GLfloat(s) ) -> None
glTexCoord1fv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b5720c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glTexCoord1fv( arrays.GLfloatArray(v) ) -> None
glTexCoord1i(...)
glTexCoord1i( GLint(s) ) -> None
glTexCoord1iv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b572ac>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glTexCoord1iv( arrays.GLintArray(v) ) -> None
glTexCoord1s(...)
glTexCoord1s( GLshort(s) ) -> None
glTexCoord1sv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b5734c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glTexCoord1sv( arrays.GLshortArray(v) ) -> None
glTexCoord2d(...)
glTexCoord2d( GLdouble(s), GLdouble(t) ) -> None
glTexCoord2dv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b573ec>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glTexCoord2dv( arrays.GLdoubleArray(v) ) -> None
glTexCoord2f(...)
glTexCoord2f( GLfloat(s), GLfloat(t) ) -> None
glTexCoord2fv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b5748c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glTexCoord2fv( arrays.GLfloatArray(v) ) -> None
glTexCoord2i(...)
glTexCoord2i( GLint(s), GLint(t) ) -> None
glTexCoord2iv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b5752c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glTexCoord2iv( arrays.GLintArray(v) ) -> None
glTexCoord2s(...)
glTexCoord2s( GLshort(s), GLshort(t) ) -> None
glTexCoord2sv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b575cc>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glTexCoord2sv( arrays.GLshortArray(v) ) -> None
glTexCoord3d(...)
glTexCoord3d( GLdouble(s), GLdouble(t), GLdouble(r) ) -> None
glTexCoord3dv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b5766c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glTexCoord3dv( arrays.GLdoubleArray(v) ) -> None
glTexCoord3f(...)
glTexCoord3f( GLfloat(s), GLfloat(t), GLfloat(r) ) -> None
glTexCoord3fv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b5770c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glTexCoord3fv( arrays.GLfloatArray(v) ) -> None
glTexCoord3i(...)
glTexCoord3i( GLint(s), GLint(t), GLint(r) ) -> None
glTexCoord3iv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b577ac>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glTexCoord3iv( arrays.GLintArray(v) ) -> None
glTexCoord3s(...)
glTexCoord3s( GLshort(s), GLshort(t), GLshort(r) ) -> None
glTexCoord3sv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b5784c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glTexCoord3sv( arrays.GLshortArray(v) ) -> None
glTexCoord4d(...)
glTexCoord4d( GLdouble(s), GLdouble(t), GLdouble(r), GLdouble(q) ) -> None
glTexCoord4dv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b578ec>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glTexCoord4dv( arrays.GLdoubleArray(v) ) -> None
glTexCoord4f(...)
glTexCoord4f( GLfloat(s), GLfloat(t), GLfloat(r), GLfloat(q) ) -> None
glTexCoord4fv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b5798c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glTexCoord4fv( arrays.GLfloatArray(v) ) -> None
glTexCoord4i(...)
glTexCoord4i( GLint(s), GLint(t), GLint(r), GLint(q) ) -> None
glTexCoord4iv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b57a2c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glTexCoord4iv( arrays.GLintArray(v) ) -> None
glTexCoord4s(...)
glTexCoord4s( GLshort(s), GLshort(t), GLshort(r), GLshort(q) ) -> None
glTexCoord4sv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b57acc>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glTexCoord4sv( arrays.GLshortArray(v) ) -> None
glTexCoordPointer( size,type,stride,pointer )
pyConverters: size=None, type=None, stride=None, pointer=<OpenGL.arrays.arrayhelpers.AsArrayOfType object at 0x82a75ec>
cConverters: Not Used
cResolvers: size=None, type=None, stride=None, pointer=
voidDataPointer(cls, value) method of type instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object at 0x82a784c>
returnValues: <OpenGL.converters.returnPyArgument object at 0x8b5ecd4>
Wrapping Operation: glTexCoordPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glTexCoordPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object at 0x87c280c>
cConverters: size=
arraySizeOfFirst(pyArgs, index, baseOperation)
Return the array size of the first argument
, type=GL_BYTE, stride=0, pointer=<OpenGL.converters.getPyArgsName object at 0x8b5e6e4>
cResolvers: size=None, type=None, stride=None, pointer=
voidDataPointer(cls, value) method of _ctypes.PointerType instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object at 0x87c29cc>
returnValues: <OpenGL.converters.returnPyArgument object at 0x8b5e734>
Wrapping Operation: glTexCoordPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glTexCoordPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object at 0x863bbec>
cConverters: size=
arraySizeOfFirst(pyArgs, index, baseOperation)
Return the array size of the first argument
, type=GL_DOUBLE, stride=0, pointer=<OpenGL.converters.getPyArgsName object at 0x8b5e48c>
cResolvers: size=None, type=None, stride=None, pointer=
voidDataPointer(cls, value) method of _ctypes.PointerType instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object at 0x863bd0c>
returnValues: <OpenGL.converters.returnPyArgument object at 0x8b5e4dc>
Wrapping Operation: glTexCoordPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glTexCoordPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object at 0x87c2bac>
cConverters: size=
arraySizeOfFirst(pyArgs, index, baseOperation)
Return the array size of the first argument
, type=GL_FLOAT, stride=0, pointer=<OpenGL.converters.getPyArgsName object at 0x8b5e554>
cResolvers: size=None, type=None, stride=None, pointer=
voidDataPointer(cls, value) method of _ctypes.PointerType instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object at 0x87c266c>
returnValues: <OpenGL.converters.returnPyArgument object at 0x8b5e5a4>
Wrapping Operation: glTexCoordPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glTexCoordPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object at 0x87c28cc>
cConverters: size=
arraySizeOfFirst(pyArgs, index, baseOperation)
Return the array size of the first argument
, type=GL_INT, stride=0, pointer=<OpenGL.converters.getPyArgsName object at 0x8b5e61c>
cResolvers: size=None, type=None, stride=None, pointer=
voidDataPointer(cls, value) method of _ctypes.PointerType instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object at 0x87c21ec>
returnValues: <OpenGL.converters.returnPyArgument object at 0x8b5e66c>
Wrapping Operation: glTexCoordPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glTexCoordPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object at 0x87c2aac>
cConverters: size=
arraySizeOfFirst(pyArgs, index, baseOperation)
Return the array size of the first argument
, type=GL_SHORT, stride=0, pointer=<OpenGL.converters.getPyArgsName object at 0x8b5e7ac>
cResolvers: size=None, type=None, stride=None, pointer=
voidDataPointer(cls, value) method of _ctypes.PointerType instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object at 0x87c2e6c>
returnValues: <OpenGL.converters.returnPyArgument object at 0x8b5e7fc>
Wrapping Operation: glTexCoordPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glTexEnvf(...)
glTexEnvf( GLenum(target), GLenum(pname), GLfloat(param) ) -> None
glTexEnvfv( target,pname,params )
pyConverters: target=None, pname=None, params=<OpenGL.converters.CallFuncPyConverter object at 0x82b13ec>
cConverters: target=None, pname=None, params=<OpenGL.converters.getPyArgsName object at 0x8b57b6c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glTexEnvfv( GLenum(target), GLenum(pname), arrays.GLfloatArray(params) ) -> None
glTexEnvi(...)
glTexEnvi( GLenum(target), GLenum(pname), GLint(param) ) -> None
glTexEnviv( target,pname,params )
pyConverters: target=None, pname=None, params=<OpenGL.converters.CallFuncPyConverter object at 0x82b1a8c>
cConverters: target=None, pname=None, params=<OpenGL.converters.getPyArgsName object at 0x8b57be4>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glTexEnviv( GLenum(target), GLenum(pname), arrays.GLintArray(params) ) -> None
glTexGend(...)
glTexGend( GLenum(coord), GLenum(pname), GLdouble(param) ) -> None
glTexGendv( coord,pname,params )
pyConverters: coord=None, pname=None, params=<OpenGL.converters.CallFuncPyConverter object at 0x82b1bac>
cConverters: coord=None, pname=None, params=<OpenGL.converters.getPyArgsName object at 0x8b57c5c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glTexGendv( GLenum(coord), GLenum(pname), arrays.GLdoubleArray(params) ) -> None
glTexGenf(...)
glTexGenf( GLenum(coord), GLenum(pname), GLfloat(param) ) -> None
glTexGenfv( coord,pname,params )
pyConverters: coord=None, pname=None, params=<OpenGL.converters.CallFuncPyConverter object at 0x87bfa4c>
cConverters: coord=None, pname=None, params=<OpenGL.converters.getPyArgsName object at 0x87a76e4>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glTexGenfv( GLenum(coord), GLenum(pname), arrays.GLfloatArray(params) ) -> None
glTexGeni(...)
glTexGeni( GLenum(coord), GLenum(pname), GLint(param) ) -> None
glTexGeniv( coord,pname,params )
pyConverters: coord=None, pname=None, params=<OpenGL.converters.CallFuncPyConverter object at 0x82b116c>
cConverters: coord=None, pname=None, params=<OpenGL.converters.getPyArgsName object at 0x8b57d4c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glTexGeniv( GLenum(coord), GLenum(pname), arrays.GLintArray(params) ) -> None
glTexImage1D( target,level,internalformat,width,border,format,type,pixels )
pyConverters: target=None, level=None, internalformat=None, width=
asIntConverter(value, *args)
, border=None, format=None, type=None, pixels=<OpenGL.GL.images.ImageInputConverter object at 0x8253b6c>
cConverters: Not Used
cResolvers: target=None, level=None, internalformat=None, width=None, border=None, format=None, type=None, pixels=
cResolver(self, array) method of ImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexImage1D( GLenum(target), GLint(level), GLint(internalformat), GLsizei(width), GLint(border), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glTexImage1D( target,level,internalformat,border,format,pixels )
pyConverters: target=None, level=None, internalformat=None, border=None, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x82930ec>
cConverters: target=None, level=None, internalformat=None, width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, border=None, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: target=None, level=None, internalformat=None, width=None, border=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexImage1D( GLenum(target), GLint(level), GLint(internalformat), GLsizei(width), GLint(border), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glTexImage1D( target,level,internalformat,border,format,pixels )
pyConverters: target=None, level=None, internalformat=None, border=None, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x829348c>
cConverters: target=None, level=None, internalformat=None, width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, border=None, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: target=None, level=None, internalformat=None, width=None, border=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexImage1D( GLenum(target), GLint(level), GLint(internalformat), GLsizei(width), GLint(border), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glTexImage1D( target,level,internalformat,border,format,pixels )
pyConverters: target=None, level=None, internalformat=None, border=None, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x829366c>
cConverters: target=None, level=None, internalformat=None, width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, border=None, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: target=None, level=None, internalformat=None, width=None, border=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexImage1D( GLenum(target), GLint(level), GLint(internalformat), GLsizei(width), GLint(border), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glTexImage1D( target,level,internalformat,border,format,pixels )
pyConverters: target=None, level=None, internalformat=None, border=None, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x87cf3ac>
cConverters: target=None, level=None, internalformat=None, width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, border=None, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: target=None, level=None, internalformat=None, width=None, border=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexImage1D( GLenum(target), GLint(level), GLint(internalformat), GLsizei(width), GLint(border), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glTexImage1D( target,level,internalformat,border,format,pixels )
pyConverters: target=None, level=None, internalformat=None, border=None, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x87cf48c>
cConverters: target=None, level=None, internalformat=None, width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, border=None, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: target=None, level=None, internalformat=None, width=None, border=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexImage1D( GLenum(target), GLint(level), GLint(internalformat), GLsizei(width), GLint(border), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glTexImage1D( target,level,internalformat,border,format,pixels )
pyConverters: target=None, level=None, internalformat=None, border=None, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x87cc7ac>
cConverters: target=None, level=None, internalformat=None, width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, border=None, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: target=None, level=None, internalformat=None, width=None, border=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexImage1D( GLenum(target), GLint(level), GLint(internalformat), GLsizei(width), GLint(border), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glTexImage1D( target,level,internalformat,border,format,pixels )
pyConverters: target=None, level=None, internalformat=None, border=None, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x87cc70c>
cConverters: target=None, level=None, internalformat=None, width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, border=None, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: target=None, level=None, internalformat=None, width=None, border=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexImage1D( GLenum(target), GLint(level), GLint(internalformat), GLsizei(width), GLint(border), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glTexImage2D( target,level,internalformat,width,height,border,format,type,pixels )
pyConverters: target=None, level=None, internalformat=None, width=
asIntConverter(value, *args)
, height=
asIntConverter(value, *args)
, border=None, format=None, type=None, pixels=<OpenGL.GL.images.ImageInputConverter object at 0x8253c8c>
cConverters: Not Used
cResolvers: target=None, level=None, internalformat=None, width=None, height=None, border=None, format=None, type=None, pixels=
cResolver(self, array) method of ImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexImage2D( GLenum(target), GLint(level), GLint(internalformat), GLsizei(width), GLsizei(height), GLint(border), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glTexImage2D( target,level,internalformat,border,format,pixels )
pyConverters: target=None, level=None, internalformat=None, border=None, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x829370c>
cConverters: target=None, level=None, internalformat=None, width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, height=
height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the height from the pixels argument
, border=None, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: target=None, level=None, internalformat=None, width=None, height=None, border=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexImage2D( GLenum(target), GLint(level), GLint(internalformat), GLsizei(width), GLsizei(height), GLint(border), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glTexImage2D( target,level,internalformat,border,format,pixels )
pyConverters: target=None, level=None, internalformat=None, border=None, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x829358c>
cConverters: target=None, level=None, internalformat=None, width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, height=
height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the height from the pixels argument
, border=None, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: target=None, level=None, internalformat=None, width=None, height=None, border=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexImage2D( GLenum(target), GLint(level), GLint(internalformat), GLsizei(width), GLsizei(height), GLint(border), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glTexImage2D( target,level,internalformat,border,format,pixels )
pyConverters: target=None, level=None, internalformat=None, border=None, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x829356c>
cConverters: target=None, level=None, internalformat=None, width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, height=
height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the height from the pixels argument
, border=None, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: target=None, level=None, internalformat=None, width=None, height=None, border=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexImage2D( GLenum(target), GLint(level), GLint(internalformat), GLsizei(width), GLsizei(height), GLint(border), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glTexImage2D( target,level,internalformat,border,format,pixels )
pyConverters: target=None, level=None, internalformat=None, border=None, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x87cfb6c>
cConverters: target=None, level=None, internalformat=None, width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, height=
height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the height from the pixels argument
, border=None, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: target=None, level=None, internalformat=None, width=None, height=None, border=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexImage2D( GLenum(target), GLint(level), GLint(internalformat), GLsizei(width), GLsizei(height), GLint(border), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glTexImage2D( target,level,internalformat,border,format,pixels )
pyConverters: target=None, level=None, internalformat=None, border=None, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x87cfd2c>
cConverters: target=None, level=None, internalformat=None, width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, height=
height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the height from the pixels argument
, border=None, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: target=None, level=None, internalformat=None, width=None, height=None, border=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexImage2D( GLenum(target), GLint(level), GLint(internalformat), GLsizei(width), GLsizei(height), GLint(border), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glTexImage2D( target,level,internalformat,border,format,pixels )
pyConverters: target=None, level=None, internalformat=None, border=None, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x87cc0cc>
cConverters: target=None, level=None, internalformat=None, width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, height=
height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the height from the pixels argument
, border=None, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: target=None, level=None, internalformat=None, width=None, height=None, border=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexImage2D( GLenum(target), GLint(level), GLint(internalformat), GLsizei(width), GLsizei(height), GLint(border), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glTexImage2D( target,level,internalformat,border,format,pixels )
pyConverters: target=None, level=None, internalformat=None, border=None, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x825240c>
cConverters: target=None, level=None, internalformat=None, width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, height=
height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the height from the pixels argument
, border=None, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: target=None, level=None, internalformat=None, width=None, height=None, border=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexImage2D( GLenum(target), GLint(level), GLint(internalformat), GLsizei(width), GLsizei(height), GLint(border), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glTexImage3D( target,level,internalformat,width,height,depth,border,format,type,pixels )
pyConverters: target=None, level=None, internalformat=None, width=
asIntConverter(value, *args)
, height=
asIntConverter(value, *args)
, depth=
asIntConverter(value, *args)
, border=None, format=None, type=None, pixels=<OpenGL.GL.images.ImageInputConverter object at 0x827ff6c>
cConverters: Not Used
cResolvers: target=None, level=None, internalformat=None, width=None, height=None, depth=None, border=None, format=None, type=None, pixels=
cResolver(self, array) method of ImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexImage3D( GLenum(target), GLint(level), GLint(internalformat), GLsizei(width), GLsizei(height), GLsizei(depth), GLint(border), GLenum(format), GLenum(type), c_void_p(pixels) ) -> None
glTexImage3D( target,level,internalformat,border,format,pixels )
pyConverters: target=None, level=None, internalformat=None, border=None, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x87be9cc>
cConverters: target=None, level=None, internalformat=None, width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, height=
height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the height from the pixels argument
, depth=
depth(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the depth from the pixels argument
, border=None, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: target=None, level=None, internalformat=None, width=None, height=None, depth=None, border=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexImage3D( GLenum(target), GLint(level), GLint(internalformat), GLsizei(width), GLsizei(height), GLsizei(depth), GLint(border), GLenum(format), GLenum(type), c_void_p(pixels) ) -> None
glTexImage3D( target,level,internalformat,border,format,pixels )
pyConverters: target=None, level=None, internalformat=None, border=None, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x87be90c>
cConverters: target=None, level=None, internalformat=None, width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, height=
height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the height from the pixels argument
, depth=
depth(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the depth from the pixels argument
, border=None, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: target=None, level=None, internalformat=None, width=None, height=None, depth=None, border=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexImage3D( GLenum(target), GLint(level), GLint(internalformat), GLsizei(width), GLsizei(height), GLsizei(depth), GLint(border), GLenum(format), GLenum(type), c_void_p(pixels) ) -> None
glTexImage3D( target,level,internalformat,border,format,pixels )
pyConverters: target=None, level=None, internalformat=None, border=None, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x87bed8c>
cConverters: target=None, level=None, internalformat=None, width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, height=
height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the height from the pixels argument
, depth=
depth(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the depth from the pixels argument
, border=None, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: target=None, level=None, internalformat=None, width=None, height=None, depth=None, border=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexImage3D( GLenum(target), GLint(level), GLint(internalformat), GLsizei(width), GLsizei(height), GLsizei(depth), GLint(border), GLenum(format), GLenum(type), c_void_p(pixels) ) -> None
glTexImage3D( target,level,internalformat,border,format,pixels )
pyConverters: target=None, level=None, internalformat=None, border=None, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x87be0ec>
cConverters: target=None, level=None, internalformat=None, width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, height=
height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the height from the pixels argument
, depth=
depth(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the depth from the pixels argument
, border=None, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: target=None, level=None, internalformat=None, width=None, height=None, depth=None, border=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexImage3D( GLenum(target), GLint(level), GLint(internalformat), GLsizei(width), GLsizei(height), GLsizei(depth), GLint(border), GLenum(format), GLenum(type), c_void_p(pixels) ) -> None
glTexImage3D( target,level,internalformat,border,format,pixels )
pyConverters: target=None, level=None, internalformat=None, border=None, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x87be56c>
cConverters: target=None, level=None, internalformat=None, width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, height=
height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the height from the pixels argument
, depth=
depth(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the depth from the pixels argument
, border=None, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: target=None, level=None, internalformat=None, width=None, height=None, depth=None, border=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexImage3D( GLenum(target), GLint(level), GLint(internalformat), GLsizei(width), GLsizei(height), GLsizei(depth), GLint(border), GLenum(format), GLenum(type), c_void_p(pixels) ) -> None
glTexImage3D( target,level,internalformat,border,format,pixels )
pyConverters: target=None, level=None, internalformat=None, border=None, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x87befec>
cConverters: target=None, level=None, internalformat=None, width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, height=
height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the height from the pixels argument
, depth=
depth(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the depth from the pixels argument
, border=None, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: target=None, level=None, internalformat=None, width=None, height=None, depth=None, border=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexImage3D( GLenum(target), GLint(level), GLint(internalformat), GLsizei(width), GLsizei(height), GLsizei(depth), GLint(border), GLenum(format), GLenum(type), c_void_p(pixels) ) -> None
glTexImage3D( target,level,internalformat,border,format,pixels )
pyConverters: target=None, level=None, internalformat=None, border=None, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x827f8ec>
cConverters: target=None, level=None, internalformat=None, width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, height=
height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the height from the pixels argument
, depth=
depth(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the depth from the pixels argument
, border=None, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: target=None, level=None, internalformat=None, width=None, height=None, depth=None, border=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexImage3D( GLenum(target), GLint(level), GLint(internalformat), GLsizei(width), GLsizei(height), GLsizei(depth), GLint(border), GLenum(format), GLenum(type), c_void_p(pixels) ) -> None
glTexParameterf(...)
glTexParameterf( GLenum(target), GLenum(pname), GLfloat(param) ) -> None
glTexParameterfv( target,pname,params )
pyConverters: target=None, pname=None, params=<OpenGL.converters.CallFuncPyConverter object at 0x82b1eec>
cConverters: target=None, pname=None, params=<OpenGL.converters.getPyArgsName object at 0x8b57dc4>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glTexParameterfv( GLenum(target), GLenum(pname), arrays.GLfloatArray(params) ) -> None
glTexParameteri(...)
glTexParameteri( GLenum(target), GLenum(pname), GLint(param) ) -> None
glTexParameteriv( target,pname,params )
pyConverters: target=None, pname=None, params=<OpenGL.converters.CallFuncPyConverter object at 0x82b102c>
cConverters: target=None, pname=None, params=<OpenGL.converters.getPyArgsName object at 0x8b57e3c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glTexParameteriv( GLenum(target), GLenum(pname), arrays.GLintArray(params) ) -> None
glTexSubImage1D( target,level,xoffset,width,format,type,pixels )
pyConverters: target=None, level=None, xoffset=
asIntConverter(value, *args)
, width=
asIntConverter(value, *args)
, format=None, type=None, pixels=<OpenGL.GL.images.ImageInputConverter object at 0x8253c4c>
cConverters: Not Used
cResolvers: target=None, level=None, xoffset=None, width=None, format=None, type=None, pixels=
cResolver(self, array) method of ImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexSubImage1D( GLenum(target), GLint(level), GLint(xoffset), GLsizei(width), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glTexSubImage1D( target,level,xoffset,format,pixels )
pyConverters: target=None, level=None, xoffset=
asIntConverter(value, *args)
, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x829372c>
cConverters: target=None, level=None, xoffset=None, width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: target=None, level=None, xoffset=None, width=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexSubImage1D( GLenum(target), GLint(level), GLint(xoffset), GLsizei(width), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glTexSubImage1D( target,level,xoffset,format,pixels )
pyConverters: target=None, level=None, xoffset=
asIntConverter(value, *args)
, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x829340c>
cConverters: target=None, level=None, xoffset=None, width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: target=None, level=None, xoffset=None, width=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexSubImage1D( GLenum(target), GLint(level), GLint(xoffset), GLsizei(width), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glTexSubImage1D( target,level,xoffset,format,pixels )
pyConverters: target=None, level=None, xoffset=
asIntConverter(value, *args)
, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x829318c>
cConverters: target=None, level=None, xoffset=None, width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: target=None, level=None, xoffset=None, width=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexSubImage1D( GLenum(target), GLint(level), GLint(xoffset), GLsizei(width), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glTexSubImage1D( target,level,xoffset,format,pixels )
pyConverters: target=None, level=None, xoffset=
asIntConverter(value, *args)
, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x87cf9ac>
cConverters: target=None, level=None, xoffset=None, width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: target=None, level=None, xoffset=None, width=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexSubImage1D( GLenum(target), GLint(level), GLint(xoffset), GLsizei(width), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glTexSubImage1D( target,level,xoffset,format,pixels )
pyConverters: target=None, level=None, xoffset=
asIntConverter(value, *args)
, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x87cce8c>
cConverters: target=None, level=None, xoffset=None, width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: target=None, level=None, xoffset=None, width=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexSubImage1D( GLenum(target), GLint(level), GLint(xoffset), GLsizei(width), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glTexSubImage1D( target,level,xoffset,format,pixels )
pyConverters: target=None, level=None, xoffset=
asIntConverter(value, *args)
, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x87cc04c>
cConverters: target=None, level=None, xoffset=None, width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: target=None, level=None, xoffset=None, width=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexSubImage1D( GLenum(target), GLint(level), GLint(xoffset), GLsizei(width), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glTexSubImage1D( target,level,xoffset,format,pixels )
pyConverters: target=None, level=None, xoffset=
asIntConverter(value, *args)
, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x8252e2c>
cConverters: target=None, level=None, xoffset=None, width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: target=None, level=None, xoffset=None, width=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexSubImage1D( GLenum(target), GLint(level), GLint(xoffset), GLsizei(width), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glTexSubImage2D( target,level,xoffset,yoffset,width,height,format,type,pixels )
pyConverters: target=None, level=None, xoffset=
asIntConverter(value, *args)
, yoffset=
asIntConverter(value, *args)
, width=
asIntConverter(value, *args)
, height=
asIntConverter(value, *args)
, format=None, type=None, pixels=<OpenGL.GL.images.ImageInputConverter object at 0x82537ac>
cConverters: Not Used
cResolvers: target=None, level=None, xoffset=None, yoffset=None, width=None, height=None, format=None, type=None, pixels=
cResolver(self, array) method of ImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexSubImage2D( GLenum(target), GLint(level), GLint(xoffset), GLint(yoffset), GLsizei(width), GLsizei(height), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glTexSubImage2D( target,level,xoffset,yoffset,format,pixels )
pyConverters: target=None, level=None, xoffset=
asIntConverter(value, *args)
, yoffset=
asIntConverter(value, *args)
, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x8293e2c>
cConverters: target=None, level=None, xoffset=None, yoffset=None, width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, height=
height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the height from the pixels argument
, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: target=None, level=None, xoffset=None, yoffset=None, width=None, height=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexSubImage2D( GLenum(target), GLint(level), GLint(xoffset), GLint(yoffset), GLsizei(width), GLsizei(height), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glTexSubImage2D( target,level,xoffset,yoffset,format,pixels )
pyConverters: target=None, level=None, xoffset=
asIntConverter(value, *args)
, yoffset=
asIntConverter(value, *args)
, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x829384c>
cConverters: target=None, level=None, xoffset=None, yoffset=None, width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, height=
height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the height from the pixels argument
, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: target=None, level=None, xoffset=None, yoffset=None, width=None, height=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexSubImage2D( GLenum(target), GLint(level), GLint(xoffset), GLint(yoffset), GLsizei(width), GLsizei(height), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glTexSubImage2D( target,level,xoffset,yoffset,format,pixels )
pyConverters: target=None, level=None, xoffset=
asIntConverter(value, *args)
, yoffset=
asIntConverter(value, *args)
, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x87cfaac>
cConverters: target=None, level=None, xoffset=None, yoffset=None, width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, height=
height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the height from the pixels argument
, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: target=None, level=None, xoffset=None, yoffset=None, width=None, height=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexSubImage2D( GLenum(target), GLint(level), GLint(xoffset), GLint(yoffset), GLsizei(width), GLsizei(height), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glTexSubImage2D( target,level,xoffset,yoffset,format,pixels )
pyConverters: target=None, level=None, xoffset=
asIntConverter(value, *args)
, yoffset=
asIntConverter(value, *args)
, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x87cf6cc>
cConverters: target=None, level=None, xoffset=None, yoffset=None, width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, height=
height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the height from the pixels argument
, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: target=None, level=None, xoffset=None, yoffset=None, width=None, height=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexSubImage2D( GLenum(target), GLint(level), GLint(xoffset), GLint(yoffset), GLsizei(width), GLsizei(height), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glTexSubImage2D( target,level,xoffset,yoffset,format,pixels )
pyConverters: target=None, level=None, xoffset=
asIntConverter(value, *args)
, yoffset=
asIntConverter(value, *args)
, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x87cc0ec>
cConverters: target=None, level=None, xoffset=None, yoffset=None, width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, height=
height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the height from the pixels argument
, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: target=None, level=None, xoffset=None, yoffset=None, width=None, height=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexSubImage2D( GLenum(target), GLint(level), GLint(xoffset), GLint(yoffset), GLsizei(width), GLsizei(height), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glTexSubImage2D( target,level,xoffset,yoffset,format,pixels )
pyConverters: target=None, level=None, xoffset=
asIntConverter(value, *args)
, yoffset=
asIntConverter(value, *args)
, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x87cc62c>
cConverters: target=None, level=None, xoffset=None, yoffset=None, width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, height=
height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the height from the pixels argument
, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: target=None, level=None, xoffset=None, yoffset=None, width=None, height=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexSubImage2D( GLenum(target), GLint(level), GLint(xoffset), GLint(yoffset), GLsizei(width), GLsizei(height), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glTexSubImage2D( target,level,xoffset,yoffset,format,pixels )
pyConverters: target=None, level=None, xoffset=
asIntConverter(value, *args)
, yoffset=
asIntConverter(value, *args)
, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x8252b6c>
cConverters: target=None, level=None, xoffset=None, yoffset=None, width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, height=
height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the height from the pixels argument
, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: target=None, level=None, xoffset=None, yoffset=None, width=None, height=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexSubImage2D( GLenum(target), GLint(level), GLint(xoffset), GLint(yoffset), GLsizei(width), GLsizei(height), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glTexSubImage3D( target,level,xoffset,yoffset,zoffset,width,height,depth,format,type,pixels )
pyConverters: target=None, level=None, xoffset=
asIntConverter(value, *args)
, yoffset=
asIntConverter(value, *args)
, zoffset=
asIntConverter(value, *args)
, width=
asIntConverter(value, *args)
, height=
asIntConverter(value, *args)
, depth=
asIntConverter(value, *args)
, format=None, type=None, pixels=<OpenGL.GL.images.ImageInputConverter object at 0x827f7cc>
cConverters: Not Used
cResolvers: target=None, level=None, xoffset=None, yoffset=None, zoffset=None, width=None, height=None, depth=None, format=None, type=None, pixels=
cResolver(self, array) method of ImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexSubImage3D( GLenum(target), GLint(level), GLint(xoffset), GLint(yoffset), GLint(zoffset), GLsizei(width), GLsizei(height), GLsizei(depth), GLenum(format), GLenum(type), c_void_p(pixels) ) -> None
glTexSubImage3D( target,level,xoffset,yoffset,zoffset,format,pixels )
pyConverters: target=None, level=None, xoffset=
asIntConverter(value, *args)
, yoffset=
asIntConverter(value, *args)
, zoffset=
asIntConverter(value, *args)
, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x87be76c>
cConverters: target=None, level=None, xoffset=None, yoffset=None, zoffset=None, width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, height=
height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the height from the pixels argument
, depth=
depth(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the depth from the pixels argument
, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: target=None, level=None, xoffset=None, yoffset=None, zoffset=None, width=None, height=None, depth=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexSubImage3D( GLenum(target), GLint(level), GLint(xoffset), GLint(yoffset), GLint(zoffset), GLsizei(width), GLsizei(height), GLsizei(depth), GLenum(format), GLenum(type), c_void_p(pixels) ) -> None
glTexSubImage3D( target,level,xoffset,yoffset,zoffset,format,pixels )
pyConverters: target=None, level=None, xoffset=
asIntConverter(value, *args)
, yoffset=
asIntConverter(value, *args)
, zoffset=
asIntConverter(value, *args)
, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x87be16c>
cConverters: target=None, level=None, xoffset=None, yoffset=None, zoffset=None, width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, height=
height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the height from the pixels argument
, depth=
depth(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the depth from the pixels argument
, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: target=None, level=None, xoffset=None, yoffset=None, zoffset=None, width=None, height=None, depth=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexSubImage3D( GLenum(target), GLint(level), GLint(xoffset), GLint(yoffset), GLint(zoffset), GLsizei(width), GLsizei(height), GLsizei(depth), GLenum(format), GLenum(type), c_void_p(pixels) ) -> None
glTexSubImage3D( target,level,xoffset,yoffset,zoffset,format,pixels )
pyConverters: target=None, level=None, xoffset=
asIntConverter(value, *args)
, yoffset=
asIntConverter(value, *args)
, zoffset=
asIntConverter(value, *args)
, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x87be74c>
cConverters: target=None, level=None, xoffset=None, yoffset=None, zoffset=None, width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, height=
height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the height from the pixels argument
, depth=
depth(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the depth from the pixels argument
, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: target=None, level=None, xoffset=None, yoffset=None, zoffset=None, width=None, height=None, depth=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexSubImage3D( GLenum(target), GLint(level), GLint(xoffset), GLint(yoffset), GLint(zoffset), GLsizei(width), GLsizei(height), GLsizei(depth), GLenum(format), GLenum(type), c_void_p(pixels) ) -> None
glTexSubImage3D( target,level,xoffset,yoffset,zoffset,format,pixels )
pyConverters: target=None, level=None, xoffset=
asIntConverter(value, *args)
, yoffset=
asIntConverter(value, *args)
, zoffset=
asIntConverter(value, *args)
, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x87bedcc>
cConverters: target=None, level=None, xoffset=None, yoffset=None, zoffset=None, width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, height=
height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the height from the pixels argument
, depth=
depth(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the depth from the pixels argument
, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: target=None, level=None, xoffset=None, yoffset=None, zoffset=None, width=None, height=None, depth=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexSubImage3D( GLenum(target), GLint(level), GLint(xoffset), GLint(yoffset), GLint(zoffset), GLsizei(width), GLsizei(height), GLsizei(depth), GLenum(format), GLenum(type), c_void_p(pixels) ) -> None
glTexSubImage3D( target,level,xoffset,yoffset,zoffset,format,pixels )
pyConverters: target=None, level=None, xoffset=
asIntConverter(value, *args)
, yoffset=
asIntConverter(value, *args)
, zoffset=
asIntConverter(value, *args)
, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x87be36c>
cConverters: target=None, level=None, xoffset=None, yoffset=None, zoffset=None, width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, height=
height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the height from the pixels argument
, depth=
depth(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the depth from the pixels argument
, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: target=None, level=None, xoffset=None, yoffset=None, zoffset=None, width=None, height=None, depth=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexSubImage3D( GLenum(target), GLint(level), GLint(xoffset), GLint(yoffset), GLint(zoffset), GLsizei(width), GLsizei(height), GLsizei(depth), GLenum(format), GLenum(type), c_void_p(pixels) ) -> None
glTexSubImage3D( target,level,xoffset,yoffset,zoffset,format,pixels )
pyConverters: target=None, level=None, xoffset=
asIntConverter(value, *args)
, yoffset=
asIntConverter(value, *args)
, zoffset=
asIntConverter(value, *args)
, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x827f54c>
cConverters: target=None, level=None, xoffset=None, yoffset=None, zoffset=None, width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, height=
height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the height from the pixels argument
, depth=
depth(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the depth from the pixels argument
, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: target=None, level=None, xoffset=None, yoffset=None, zoffset=None, width=None, height=None, depth=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexSubImage3D( GLenum(target), GLint(level), GLint(xoffset), GLint(yoffset), GLint(zoffset), GLsizei(width), GLsizei(height), GLsizei(depth), GLenum(format), GLenum(type), c_void_p(pixels) ) -> None
glTexSubImage3D( target,level,xoffset,yoffset,zoffset,format,pixels )
pyConverters: target=None, level=None, xoffset=
asIntConverter(value, *args)
, yoffset=
asIntConverter(value, *args)
, zoffset=
asIntConverter(value, *args)
, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x827f80c>
cConverters: target=None, level=None, xoffset=None, yoffset=None, zoffset=None, width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, height=
height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the height from the pixels argument
, depth=
depth(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the depth from the pixels argument
, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: target=None, level=None, xoffset=None, yoffset=None, zoffset=None, width=None, height=None, depth=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexSubImage3D( GLenum(target), GLint(level), GLint(xoffset), GLint(yoffset), GLint(zoffset), GLsizei(width), GLsizei(height), GLsizei(depth), GLenum(format), GLenum(type), c_void_p(pixels) ) -> None
glTranslate = glTranslated(...)
glTranslated( GLdouble(x), GLdouble(y), GLdouble(z) ) -> None
glTranslated(...)
glTranslated( GLdouble(x), GLdouble(y), GLdouble(z) ) -> None
glTranslatef(...)
glTranslatef( GLfloat(x), GLfloat(y), GLfloat(z) ) -> None
glUniform1f(...)
glUniform1f( GLint(location), GLfloat(v0) ) -> None
glUniform1fv( location,count,value )
pyConverters: location=None, count=None, value=
asArraySize(incoming, function, args)
cConverters: location=None, count=None, value=<OpenGL.converters.getPyArgsName object at 0x86b9964>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glUniform1fv( GLint(location), GLsizei(count), GLfloatArray(value) ) -> None
glUniform1i(...)
glUniform1i( GLint(location), GLint(v0) ) -> None
glUniform1iv( location,count,value )
pyConverters: location=None, count=None, value=
asArraySize(incoming, function, args)
cConverters: location=None, count=None, value=<OpenGL.converters.getPyArgsName object at 0x86b9a2c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glUniform1iv( GLint(location), GLsizei(count), GLintArray(value) ) -> None
glUniform2f(...)
glUniform2f( GLint(location), GLfloat(v0), GLfloat(v1) ) -> None
glUniform2fv( location,count,value )
pyConverters: location=None, count=None, value=
asArraySize(incoming, function, args)
cConverters: location=None, count=None, value=<OpenGL.converters.getPyArgsName object at 0x86b9b1c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glUniform2fv( GLint(location), GLsizei(count), GLfloatArray(value) ) -> None
glUniform2i(...)
glUniform2i( GLint(location), GLint(v0), GLint(v1) ) -> None
glUniform2iv( location,count,value )
pyConverters: location=None, count=None, value=
asArraySize(incoming, function, args)
cConverters: location=None, count=None, value=<OpenGL.converters.getPyArgsName object at 0x86b9c0c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glUniform2iv( GLint(location), GLsizei(count), GLintArray(value) ) -> None
glUniform3f(...)
glUniform3f( GLint(location), GLfloat(v0), GLfloat(v1), GLfloat(v2) ) -> None
glUniform3fv( location,count,value )
pyConverters: location=None, count=None, value=
asArraySize(incoming, function, args)
cConverters: location=None, count=None, value=<OpenGL.converters.getPyArgsName object at 0x86b9cfc>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glUniform3fv( GLint(location), GLsizei(count), GLfloatArray(value) ) -> None
glUniform3i(...)
glUniform3i( GLint(location), GLint(v0), GLint(v1), GLint(v2) ) -> None
glUniform3iv( location,count,value )
pyConverters: location=None, count=None, value=
asArraySize(incoming, function, args)
cConverters: location=None, count=None, value=<OpenGL.converters.getPyArgsName object at 0x86b9dec>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glUniform3iv( GLint(location), GLsizei(count), GLintArray(value) ) -> None
glUniform4f(...)
glUniform4f( GLint(location), GLfloat(v0), GLfloat(v1), GLfloat(v2), GLfloat(v3) ) -> None
glUniform4fv( location,count,value )
pyConverters: location=None, count=None, value=
asArraySize(incoming, function, args)
cConverters: location=None, count=None, value=<OpenGL.converters.getPyArgsName object at 0x86b9edc>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glUniform4fv( GLint(location), GLsizei(count), GLfloatArray(value) ) -> None
glUniform4i(...)
glUniform4i( GLint(location), GLint(v0), GLint(v1), GLint(v2), GLint(v3) ) -> None
glUniform4iv( location,count,value )
pyConverters: location=None, count=None, value=
asArraySize(incoming, function, args)
cConverters: location=None, count=None, value=<OpenGL.converters.getPyArgsName object at 0x86b9fcc>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glUniform4iv( GLint(location), GLsizei(count), GLintArray(value) ) -> None
glUniformMatrix2fv(...)
glUniformMatrix2fv( GLint(location), GLsizei(count), GLboolean(transpose), GLfloatArray(value) ) -> None
glUniformMatrix2x3fv(...)
glUniformMatrix2x3fv( GLint(location), GLsizei(count), GLboolean(transpose), GLfloatArray(value) ) -> None
glUniformMatrix2x4fv(...)
glUniformMatrix2x4fv( GLint(location), GLsizei(count), GLboolean(transpose), GLfloatArray(value) ) -> None
glUniformMatrix3fv(...)
glUniformMatrix3fv( GLint(location), GLsizei(count), GLboolean(transpose), GLfloatArray(value) ) -> None
glUniformMatrix3x2fv(...)
glUniformMatrix3x2fv( GLint(location), GLsizei(count), GLboolean(transpose), GLfloatArray(value) ) -> None
glUniformMatrix3x4fv(...)
glUniformMatrix3x4fv( GLint(location), GLsizei(count), GLboolean(transpose), GLfloatArray(value) ) -> None
glUniformMatrix4fv(...)
glUniformMatrix4fv( GLint(location), GLsizei(count), GLboolean(transpose), GLfloatArray(value) ) -> None
glUniformMatrix4x2fv(...)
glUniformMatrix4x2fv( GLint(location), GLsizei(count), GLboolean(transpose), GLfloatArray(value) ) -> None
glUniformMatrix4x3fv(...)
glUniformMatrix4x3fv( GLint(location), GLsizei(count), GLboolean(transpose), GLfloatArray(value) ) -> None
glUnmapBuffer(...)
glUnmapBuffer( GLenum(target) ) -> constants.GLboolean
glUseProgram(...)
glUseProgram( GLuint(program) ) -> None
glValidateProgram(...)
glValidateProgram( GLuint(program) ) -> None
glVertex2d(...)
glVertex2d( GLdouble(x), GLdouble(y) ) -> None
glVertex2dv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b57eb4>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glVertex2dv( arrays.GLdoubleArray(v) ) -> None
glVertex2f(...)
glVertex2f( GLfloat(x), GLfloat(y) ) -> None
glVertex2fv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b57f54>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glVertex2fv( arrays.GLfloatArray(v) ) -> None
glVertex2i(...)
glVertex2i( GLint(x), GLint(y) ) -> None
glVertex2iv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b5a02c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glVertex2iv( arrays.GLintArray(v) ) -> None
glVertex2s(...)
glVertex2s( GLshort(x), GLshort(y) ) -> None
glVertex2sv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b5a0cc>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glVertex2sv( arrays.GLshortArray(v) ) -> None
glVertex3d(...)
glVertex3d( GLdouble(x), GLdouble(y), GLdouble(z) ) -> None
glVertex3dv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b5a16c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glVertex3dv( arrays.GLdoubleArray(v) ) -> None
glVertex3f(...)
glVertex3f( GLfloat(x), GLfloat(y), GLfloat(z) ) -> None
glVertex3fv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b5a20c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glVertex3fv( arrays.GLfloatArray(v) ) -> None
glVertex3i(...)
glVertex3i( GLint(x), GLint(y), GLint(z) ) -> None
glVertex3iv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b5a2ac>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glVertex3iv( arrays.GLintArray(v) ) -> None
glVertex3s(...)
glVertex3s( GLshort(x), GLshort(y), GLshort(z) ) -> None
glVertex3sv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b5a34c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glVertex3sv( arrays.GLshortArray(v) ) -> None
glVertex4d(...)
glVertex4d( GLdouble(x), GLdouble(y), GLdouble(z), GLdouble(w) ) -> None
glVertex4dv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b5a3ec>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glVertex4dv( arrays.GLdoubleArray(v) ) -> None
glVertex4f(...)
glVertex4f( GLfloat(x), GLfloat(y), GLfloat(z), GLfloat(w) ) -> None
glVertex4fv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b5a48c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glVertex4fv( arrays.GLfloatArray(v) ) -> None
glVertex4i(...)
glVertex4i( GLint(x), GLint(y), GLint(z), GLint(w) ) -> None
glVertex4iv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b5a52c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glVertex4iv( arrays.GLintArray(v) ) -> None
glVertex4s(...)
glVertex4s( GLshort(x), GLshort(y), GLshort(z), GLshort(w) ) -> None
glVertex4sv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b5a5cc>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glVertex4sv( arrays.GLshortArray(v) ) -> None
glVertexAttrib1d(...)
glVertexAttrib1d( GLuint(index), GLdouble(x) ) -> None
glVertexAttrib1dv(...)
glVertexAttrib1dv( GLuint(index), GLdoubleArray(v) ) -> None
glVertexAttrib1f(...)
glVertexAttrib1f( GLuint(index), GLfloat(x) ) -> None
glVertexAttrib1fv(...)
glVertexAttrib1fv( GLuint(index), GLfloatArray(v) ) -> None
glVertexAttrib1s(...)
glVertexAttrib1s( GLuint(index), GLshort(x) ) -> None
glVertexAttrib1sv(...)
glVertexAttrib1sv( GLuint(index), GLshortArray(v) ) -> None
glVertexAttrib2d(...)
glVertexAttrib2d( GLuint(index), GLdouble(x), GLdouble(y) ) -> None
glVertexAttrib2dv(...)
glVertexAttrib2dv( GLuint(index), GLdoubleArray(v) ) -> None
glVertexAttrib2f(...)
glVertexAttrib2f( GLuint(index), GLfloat(x), GLfloat(y) ) -> None
glVertexAttrib2fv(...)
glVertexAttrib2fv( GLuint(index), GLfloatArray(v) ) -> None
glVertexAttrib2s(...)
glVertexAttrib2s( GLuint(index), GLshort(x), GLshort(y) ) -> None
glVertexAttrib2sv(...)
glVertexAttrib2sv( GLuint(index), GLshortArray(v) ) -> None
glVertexAttrib3d(...)
glVertexAttrib3d( GLuint(index), GLdouble(x), GLdouble(y), GLdouble(z) ) -> None
glVertexAttrib3dv(...)
glVertexAttrib3dv( GLuint(index), GLdoubleArray(v) ) -> None
glVertexAttrib3f(...)
glVertexAttrib3f( GLuint(index), GLfloat(x), GLfloat(y), GLfloat(z) ) -> None
glVertexAttrib3fv(...)
glVertexAttrib3fv( GLuint(index), GLfloatArray(v) ) -> None
glVertexAttrib3s(...)
glVertexAttrib3s( GLuint(index), GLshort(x), GLshort(y), GLshort(z) ) -> None
glVertexAttrib3sv(...)
glVertexAttrib3sv( GLuint(index), GLshortArray(v) ) -> None
glVertexAttrib4Nbv(...)
glVertexAttrib4Nbv( GLuint(index), GLbyteArray(v) ) -> None
glVertexAttrib4Niv(...)
glVertexAttrib4Niv( GLuint(index), GLintArray(v) ) -> None
glVertexAttrib4Nsv(...)
glVertexAttrib4Nsv( GLuint(index), GLshortArray(v) ) -> None
glVertexAttrib4Nub(...)
glVertexAttrib4Nub( GLuint(index), GLubyte(x), GLubyte(y), GLubyte(z), GLubyte(w) ) -> None
glVertexAttrib4Nubv(...)
glVertexAttrib4Nubv( GLuint(index), GLubyteArray(v) ) -> None
glVertexAttrib4Nuiv(...)
glVertexAttrib4Nuiv( GLuint(index), GLuintArray(v) ) -> None
glVertexAttrib4Nusv(...)
glVertexAttrib4Nusv( GLuint(index), GLushortArray(v) ) -> None
glVertexAttrib4bv(...)
glVertexAttrib4bv( GLuint(index), GLbyteArray(v) ) -> None
glVertexAttrib4d(...)
glVertexAttrib4d( GLuint(index), GLdouble(x), GLdouble(y), GLdouble(z), GLdouble(w) ) -> None
glVertexAttrib4dv(...)
glVertexAttrib4dv( GLuint(index), GLdoubleArray(v) ) -> None
glVertexAttrib4f(...)
glVertexAttrib4f( GLuint(index), GLfloat(x), GLfloat(y), GLfloat(z), GLfloat(w) ) -> None
glVertexAttrib4fv(...)
glVertexAttrib4fv( GLuint(index), GLfloatArray(v) ) -> None
glVertexAttrib4iv(...)
glVertexAttrib4iv( GLuint(index), GLintArray(v) ) -> None
glVertexAttrib4s(...)
glVertexAttrib4s( GLuint(index), GLshort(x), GLshort(y), GLshort(z), GLshort(w) ) -> None
glVertexAttrib4sv(...)
glVertexAttrib4sv( GLuint(index), GLshortArray(v) ) -> None
glVertexAttrib4ubv(...)
glVertexAttrib4ubv( GLuint(index), GLubyteArray(v) ) -> None
glVertexAttrib4uiv(...)
glVertexAttrib4uiv( GLuint(index), GLuintArray(v) ) -> None
glVertexAttrib4usv(...)
glVertexAttrib4usv( GLuint(index), GLushortArray(v) ) -> None
glVertexAttribPointer(...)
glVertexAttribPointer( GLuint(index), GLint(size), GLenum(type), GLboolean(normalized), GLsizei(stride), c_void_p(pointer) ) -> None
glVertexPointer( size,type,stride,pointer )
pyConverters: size=None, type=None, stride=None, pointer=<OpenGL.arrays.arrayhelpers.AsArrayOfType object at 0x82a744c>
cConverters: Not Used
cResolvers: size=None, type=None, stride=None, pointer=
voidDataPointer(cls, value) method of type instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object at 0x82a780c>
returnValues: <OpenGL.converters.returnPyArgument object at 0x8b5ec5c>
Wrapping Operation: glVertexPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glVertexPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object at 0x87c2c0c>
cConverters: size=
arraySizeOfFirst(pyArgs, index, baseOperation)
Return the array size of the first argument
, type=GL_INT, stride=0, pointer=<OpenGL.converters.getPyArgsName object at 0x8b5eacc>
cResolvers: size=None, type=None, stride=None, pointer=
voidDataPointer(cls, value) method of _ctypes.PointerType instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object at 0x87c26cc>
returnValues: <OpenGL.converters.returnPyArgument object at 0x8b5eb1c>
Wrapping Operation: glVertexPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glVertexPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object at 0x87c2d0c>
cConverters: size=
arraySizeOfFirst(pyArgs, index, baseOperation)
Return the array size of the first argument
, type=GL_DOUBLE, stride=0, pointer=<OpenGL.converters.getPyArgsName object at 0x8b5e874>
cResolvers: size=None, type=None, stride=None, pointer=
voidDataPointer(cls, value) method of _ctypes.PointerType instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object at 0x87c22cc>
returnValues: <OpenGL.converters.returnPyArgument object at 0x8b5e8c4>
Wrapping Operation: glVertexPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glVertexPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object at 0x87c230c>
cConverters: size=
arraySizeOfFirst(pyArgs, index, baseOperation)
Return the array size of the first argument
, type=GL_FLOAT, stride=0, pointer=<OpenGL.converters.getPyArgsName object at 0x8b5e93c>
cResolvers: size=None, type=None, stride=None, pointer=
voidDataPointer(cls, value) method of _ctypes.PointerType instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object at 0x87c220c>
returnValues: <OpenGL.converters.returnPyArgument object at 0x8b5e98c>
Wrapping Operation: glVertexPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glVertexPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object at 0x87c2e0c>
cConverters: size=
arraySizeOfFirst(pyArgs, index, baseOperation)
Return the array size of the first argument
, type=GL_INT, stride=0, pointer=<OpenGL.converters.getPyArgsName object at 0x8b5ea04>
cResolvers: size=None, type=None, stride=None, pointer=
voidDataPointer(cls, value) method of _ctypes.PointerType instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object at 0x87c2aec>
returnValues: <OpenGL.converters.returnPyArgument object at 0x8b5ea54>
Wrapping Operation: glVertexPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glVertexPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object at 0x87c290c>
cConverters: size=
arraySizeOfFirst(pyArgs, index, baseOperation)
Return the array size of the first argument
, type=GL_SHORT, stride=0, pointer=<OpenGL.converters.getPyArgsName object at 0x8b5eb94>
cResolvers: size=None, type=None, stride=None, pointer=
voidDataPointer(cls, value) method of _ctypes.PointerType instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object at 0x87c2e4c>
returnValues: <OpenGL.converters.returnPyArgument object at 0x8b5ebe4>
Wrapping Operation: glVertexPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glViewport(...)
glViewport( GLint(x), GLint(y), GLsizei(width), GLsizei(height) ) -> None
glWindowPos2d(...)
glWindowPos2d( GLdouble(x), GLdouble(y) ) -> None
glWindowPos2dv(...)
glWindowPos2dv( GLdoubleArray(v) ) -> None
glWindowPos2f(...)
glWindowPos2f( GLfloat(x), GLfloat(y) ) -> None
glWindowPos2fv(...)
glWindowPos2fv( GLfloatArray(v) ) -> None
glWindowPos2i(...)
glWindowPos2i( GLint(x), GLint(y) ) -> None
glWindowPos2iv(...)
glWindowPos2iv( GLintArray(v) ) -> None
glWindowPos2s(...)
glWindowPos2s( GLshort(x), GLshort(y) ) -> None
glWindowPos2sv(...)
glWindowPos2sv( GLshortArray(v) ) -> None
glWindowPos3d(...)
glWindowPos3d( GLdouble(x), GLdouble(y), GLdouble(z) ) -> None
glWindowPos3dv(...)
glWindowPos3dv( GLdoubleArray(v) ) -> None
glWindowPos3f(...)
glWindowPos3f( GLfloat(x), GLfloat(y), GLfloat(z) ) -> None
glWindowPos3fv(...)
glWindowPos3fv( GLfloatArray(v) ) -> None
glWindowPos3i(...)
glWindowPos3i( GLint(x), GLint(y), GLint(z) ) -> None
glWindowPos3iv(...)
glWindowPos3iv( GLintArray(v) ) -> None
glWindowPos3s(...)
glWindowPos3s( GLshort(x), GLshort(y), GLshort(z) ) -> None
glWindowPos3sv(...)
glWindowPos3sv( GLshortArray(v) ) -> None

 
Data
        GL_1PASS_EXT = GL_1PASS_EXT
GL_1PASS_SGIS = GL_1PASS_SGIS
GL_2D = GL_2D
GL_2PASS_0_EXT = GL_2PASS_0_EXT
GL_2PASS_0_SGIS = GL_2PASS_0_SGIS
GL_2PASS_1_EXT = GL_2PASS_1_EXT
GL_2PASS_1_SGIS = GL_2PASS_1_SGIS
GL_2X_BIT_ATI = GL_2X_BIT_ATI
GL_2_BYTES = GL_2_BYTES
GL_3D = GL_3D
GL_3D_COLOR = GL_3D_COLOR
GL_3D_COLOR_TEXTURE = GL_3D_COLOR_TEXTURE
GL_3_BYTES = GL_3_BYTES
GL_422_AVERAGE_EXT = GL_422_AVERAGE_EXT
GL_422_EXT = GL_422_EXT
GL_422_REV_AVERAGE_EXT = GL_422_REV_AVERAGE_EXT
GL_422_REV_EXT = GL_422_REV_EXT
GL_4D_COLOR_TEXTURE = GL_4D_COLOR_TEXTURE
GL_4PASS_0_EXT = GL_4PASS_0_EXT
GL_4PASS_0_SGIS = GL_4PASS_0_SGIS
GL_4PASS_1_EXT = GL_4PASS_1_EXT
GL_4PASS_1_SGIS = GL_4PASS_1_SGIS
GL_4PASS_2_EXT = GL_4PASS_2_EXT
GL_4PASS_2_SGIS = GL_4PASS_2_SGIS
GL_4PASS_3_EXT = GL_4PASS_3_EXT
GL_4PASS_3_SGIS = GL_4PASS_3_SGIS
GL_4X_BIT_ATI = GL_4X_BIT_ATI
GL_4_BYTES = GL_4_BYTES
GL_8X_BIT_ATI = GL_8X_BIT_ATI
GL_ABGR_EXT = GL_ABGR_EXT
GL_ACCUM = GL_ACCUM
GL_ACCUM_ALPHA_BITS = GL_ACCUM_ALPHA_BITS
GL_ACCUM_BLUE_BITS = GL_ACCUM_BLUE_BITS
GL_ACCUM_BUFFER_BIT = GL_ACCUM_BUFFER_BIT
GL_ACCUM_CLEAR_VALUE = GL_ACCUM_CLEAR_VALUE
GL_ACCUM_GREEN_BITS = GL_ACCUM_GREEN_BITS
GL_ACCUM_RED_BITS = GL_ACCUM_RED_BITS
GL_ACTIVE_ATTRIBUTES = GL_ACTIVE_ATTRIBUTES
GL_ACTIVE_ATTRIBUTE_MAX_LENGTH = GL_ACTIVE_ATTRIBUTE_MAX_LENGTH
GL_ACTIVE_STENCIL_FACE_EXT = GL_ACTIVE_STENCIL_FACE_EXT
GL_ACTIVE_TEXTURE = GL_ACTIVE_TEXTURE
GL_ACTIVE_TEXTURE_ARB = GL_ACTIVE_TEXTURE_ARB
GL_ACTIVE_UNIFORMS = GL_ACTIVE_UNIFORMS
GL_ACTIVE_UNIFORM_MAX_LENGTH = GL_ACTIVE_UNIFORM_MAX_LENGTH
GL_ACTIVE_VERTEX_UNITS_ARB = GL_ACTIVE_VERTEX_UNITS_ARB
GL_ADD = GL_ADD
GL_ADD_ATI = GL_ADD_ATI
GL_ADD_SIGNED = GL_ADD_SIGNED
GL_ADD_SIGNED_ARB = GL_ADD_SIGNED_ARB
GL_ADD_SIGNED_EXT = GL_ADD_SIGNED_EXT
GL_ALIASED_LINE_WIDTH_RANGE = GL_ALIASED_LINE_WIDTH_RANGE
GL_ALIASED_POINT_SIZE_RANGE = GL_ALIASED_POINT_SIZE_RANGE
GL_ALLOW_DRAW_FRG_HINT_PGI = GL_ALLOW_DRAW_FRG_HINT_PGI
GL_ALLOW_DRAW_MEM_HINT_PGI = GL_ALLOW_DRAW_MEM_HINT_PGI
GL_ALLOW_DRAW_OBJ_HINT_PGI = GL_ALLOW_DRAW_OBJ_HINT_PGI
GL_ALLOW_DRAW_WIN_HINT_PGI = GL_ALLOW_DRAW_WIN_HINT_PGI
GL_ALL_ATTRIB_BITS = GL_ALL_ATTRIB_BITS
GL_ALL_COMPLETED_NV = GL_ALL_COMPLETED_NV
GL_ALPHA = GL_ALPHA
GL_ALPHA12 = GL_ALPHA12
GL_ALPHA12_EXT = GL_ALPHA12_EXT
GL_ALPHA16 = GL_ALPHA16
GL_ALPHA16F_ARB = GL_ALPHA16F_ARB
GL_ALPHA16_EXT = GL_ALPHA16_EXT
GL_ALPHA32F_ARB = GL_ALPHA32F_ARB
GL_ALPHA4 = GL_ALPHA4
GL_ALPHA4_EXT = GL_ALPHA4_EXT
GL_ALPHA8 = GL_ALPHA8
GL_ALPHA8_EXT = GL_ALPHA8_EXT
GL_ALPHA_BIAS = GL_ALPHA_BIAS
GL_ALPHA_BITS = GL_ALPHA_BITS
GL_ALPHA_FLOAT16_ATI = GL_ALPHA_FLOAT16_ATI
GL_ALPHA_FLOAT32_ATI = GL_ALPHA_FLOAT32_ATI
GL_ALPHA_MAX_CLAMP_INGR = GL_ALPHA_MAX_CLAMP_INGR
GL_ALPHA_MAX_SGIX = GL_ALPHA_MAX_SGIX
GL_ALPHA_MIN_CLAMP_INGR = GL_ALPHA_MIN_CLAMP_INGR
GL_ALPHA_MIN_SGIX = GL_ALPHA_MIN_SGIX
GL_ALPHA_SCALE = GL_ALPHA_SCALE
GL_ALPHA_TEST = GL_ALPHA_TEST
GL_ALPHA_TEST_FUNC = GL_ALPHA_TEST_FUNC
GL_ALPHA_TEST_REF = GL_ALPHA_TEST_REF
GL_ALWAYS = GL_ALWAYS
GL_ALWAYS_FAST_HINT_PGI = GL_ALWAYS_FAST_HINT_PGI
GL_ALWAYS_SOFT_HINT_PGI = GL_ALWAYS_SOFT_HINT_PGI
GL_AMBIENT = GL_AMBIENT
GL_AMBIENT_AND_DIFFUSE = GL_AMBIENT_AND_DIFFUSE
GL_AND = GL_AND
GL_AND_INVERTED = GL_AND_INVERTED
GL_AND_REVERSE = GL_AND_REVERSE
GL_ARRAY_BUFFER = GL_ARRAY_BUFFER
GL_ARRAY_BUFFER_ARB = GL_ARRAY_BUFFER_ARB
GL_ARRAY_BUFFER_BINDING = GL_ARRAY_BUFFER_BINDING
GL_ARRAY_BUFFER_BINDING_ARB = GL_ARRAY_BUFFER_BINDING_ARB
GL_ARRAY_ELEMENT_LOCK_COUNT_EXT = GL_ARRAY_ELEMENT_LOCK_COUNT_EXT
GL_ARRAY_ELEMENT_LOCK_FIRST_EXT = GL_ARRAY_ELEMENT_LOCK_FIRST_EXT
GL_ARRAY_OBJECT_BUFFER_ATI = GL_ARRAY_OBJECT_BUFFER_ATI
GL_ARRAY_OBJECT_OFFSET_ATI = GL_ARRAY_OBJECT_OFFSET_ATI
GL_ASYNC_DRAW_PIXELS_SGIX = GL_ASYNC_DRAW_PIXELS_SGIX
GL_ASYNC_HISTOGRAM_SGIX = GL_ASYNC_HISTOGRAM_SGIX
GL_ASYNC_MARKER_SGIX = GL_ASYNC_MARKER_SGIX
GL_ASYNC_READ_PIXELS_SGIX = GL_ASYNC_READ_PIXELS_SGIX
GL_ASYNC_TEX_IMAGE_SGIX = GL_ASYNC_TEX_IMAGE_SGIX
GL_ATTACHED_SHADERS = GL_ATTACHED_SHADERS
GL_ATTENUATION_EXT = GL_ATTENUATION_EXT
GL_ATTRIB_ARRAY_POINTER_NV = GL_ATTRIB_ARRAY_POINTER_NV
GL_ATTRIB_ARRAY_SIZE_NV = GL_ATTRIB_ARRAY_SIZE_NV
GL_ATTRIB_ARRAY_STRIDE_NV = GL_ATTRIB_ARRAY_STRIDE_NV
GL_ATTRIB_ARRAY_TYPE_NV = GL_ATTRIB_ARRAY_TYPE_NV
GL_ATTRIB_STACK_DEPTH = GL_ATTRIB_STACK_DEPTH
GL_AUTO_NORMAL = GL_AUTO_NORMAL
GL_AUX0 = GL_AUX0
GL_AUX1 = GL_AUX1
GL_AUX2 = GL_AUX2
GL_AUX3 = GL_AUX3
GL_AUX_BUFFERS = GL_AUX_BUFFERS
GL_AVERAGE_EXT = GL_AVERAGE_EXT
GL_AVERAGE_HP = GL_AVERAGE_HP
GL_BACK = GL_BACK
GL_BACK_LEFT = GL_BACK_LEFT
GL_BACK_NORMALS_HINT_PGI = GL_BACK_NORMALS_HINT_PGI
GL_BACK_RIGHT = GL_BACK_RIGHT
GL_BGR = GL_BGR
GL_BGRA = GL_BGRA
GL_BGRA_EXT = GL_BGRA_EXT
GL_BGR_EXT = GL_BGR_EXT
GL_BIAS_BIT_ATI = GL_BIAS_BIT_ATI
GL_BIAS_BY_NEGATIVE_ONE_HALF_NV = GL_BIAS_BY_NEGATIVE_ONE_HALF_NV
GL_BINORMAL_ARRAY_EXT = GL_BINORMAL_ARRAY_EXT
GL_BINORMAL_ARRAY_POINTER_EXT = GL_BINORMAL_ARRAY_POINTER_EXT
GL_BINORMAL_ARRAY_STRIDE_EXT = GL_BINORMAL_ARRAY_STRIDE_EXT
GL_BINORMAL_ARRAY_TYPE_EXT = GL_BINORMAL_ARRAY_TYPE_EXT
GL_BITMAP = GL_BITMAP
GL_BITMAP_TOKEN = GL_BITMAP_TOKEN
GL_BLEND = GL_BLEND
GL_BLEND_COLOR = GL_BLEND_COLOR
GL_BLEND_COLOR_EXT = GL_BLEND_COLOR_EXT
GL_BLEND_DST = GL_BLEND_DST
GL_BLEND_DST_ALPHA = GL_BLEND_DST_ALPHA
GL_BLEND_DST_ALPHA_EXT = GL_BLEND_DST_ALPHA_EXT
GL_BLEND_DST_RGB = GL_BLEND_DST_RGB
GL_BLEND_DST_RGB_EXT = GL_BLEND_DST_RGB_EXT
GL_BLEND_EQUATION = GL_BLEND_EQUATION
GL_BLEND_EQUATION_ALPHA = GL_BLEND_EQUATION_ALPHA
GL_BLEND_EQUATION_ALPHA_EXT = GL_BLEND_EQUATION_ALPHA_EXT
GL_BLEND_EQUATION_EXT = GL_BLEND_EQUATION_EXT
GL_BLEND_EQUATION_RGB = GL_BLEND_EQUATION
GL_BLEND_EQUATION_RGB_EXT = GL_BLEND_EQUATION
GL_BLEND_SRC = GL_BLEND_SRC
GL_BLEND_SRC_ALPHA = GL_BLEND_SRC_ALPHA
GL_BLEND_SRC_ALPHA_EXT = GL_BLEND_SRC_ALPHA_EXT
GL_BLEND_SRC_RGB = GL_BLEND_SRC_RGB
GL_BLEND_SRC_RGB_EXT = GL_BLEND_SRC_RGB_EXT
GL_BLUE = GL_BLUE
GL_BLUE_BIAS = GL_BLUE_BIAS
GL_BLUE_BITS = GL_BLUE_BITS
GL_BLUE_BIT_ATI = GL_BLUE_BIT_ATI
GL_BLUE_MAX_CLAMP_INGR = GL_BLUE_MAX_CLAMP_INGR
GL_BLUE_MIN_CLAMP_INGR = GL_BLUE_MIN_CLAMP_INGR
GL_BLUE_SCALE = GL_BLUE_SCALE
GL_BOOL = GL_BOOL
GL_BOOL_ARB = GL_BOOL_ARB
GL_BOOL_VEC2 = GL_BOOL_VEC2
GL_BOOL_VEC2_ARB = GL_BOOL_VEC2_ARB
GL_BOOL_VEC3 = GL_BOOL_VEC3
GL_BOOL_VEC3_ARB = GL_BOOL_VEC3_ARB
GL_BOOL_VEC4 = GL_BOOL_VEC4
GL_BOOL_VEC4_ARB = GL_BOOL_VEC4_ARB
GL_BUFFER_ACCESS = GL_BUFFER_ACCESS
GL_BUFFER_ACCESS_ARB = GL_BUFFER_ACCESS_ARB
GL_BUFFER_MAPPED = GL_BUFFER_MAPPED
GL_BUFFER_MAPPED_ARB = GL_BUFFER_MAPPED_ARB
GL_BUFFER_MAP_POINTER = GL_BUFFER_MAP_POINTER
GL_BUFFER_MAP_POINTER_ARB = GL_BUFFER_MAP_POINTER_ARB
GL_BUFFER_SIZE = GL_BUFFER_SIZE
GL_BUFFER_SIZE_ARB = GL_BUFFER_SIZE_ARB
GL_BUFFER_USAGE = GL_BUFFER_USAGE
GL_BUFFER_USAGE_ARB = GL_BUFFER_USAGE_ARB
GL_BUMP_ENVMAP_ATI = GL_BUMP_ENVMAP_ATI
GL_BUMP_NUM_TEX_UNITS_ATI = GL_BUMP_NUM_TEX_UNITS_ATI
GL_BUMP_ROT_MATRIX_ATI = GL_BUMP_ROT_MATRIX_ATI
GL_BUMP_ROT_MATRIX_SIZE_ATI = GL_BUMP_ROT_MATRIX_SIZE_ATI
GL_BUMP_TARGET_ATI = GL_BUMP_TARGET_ATI
GL_BUMP_TEX_UNITS_ATI = GL_BUMP_TEX_UNITS_ATI
GL_BYTE = GL_BYTE
GL_C3F_V3F = GL_C3F_V3F
GL_C4F_N3F_V3F = GL_C4F_N3F_V3F
GL_C4UB_V2F = GL_C4UB_V2F
GL_C4UB_V3F = GL_C4UB_V3F
GL_CALLIGRAPHIC_FRAGMENT_SGIX = GL_CALLIGRAPHIC_FRAGMENT_SGIX
GL_CCW = GL_CCW
GL_CLAMP = GL_CLAMP
GL_CLAMP_FRAGMENT_COLOR_ARB = GL_CLAMP_FRAGMENT_COLOR_ARB
GL_CLAMP_READ_COLOR_ARB = GL_CLAMP_READ_COLOR_ARB
GL_CLAMP_TO_BORDER = GL_CLAMP_TO_BORDER
GL_CLAMP_TO_BORDER_ARB = GL_CLAMP_TO_BORDER_ARB
GL_CLAMP_TO_BORDER_SGIS = GL_CLAMP_TO_BORDER_SGIS
GL_CLAMP_TO_EDGE = GL_CLAMP_TO_EDGE
GL_CLAMP_TO_EDGE_SGIS = GL_CLAMP_TO_EDGE_SGIS
GL_CLAMP_VERTEX_COLOR_ARB = GL_CLAMP_VERTEX_COLOR_ARB
GL_CLEAR = GL_CLEAR
GL_CLIENT_ACTIVE_TEXTURE = GL_CLIENT_ACTIVE_TEXTURE
GL_CLIENT_ACTIVE_TEXTURE_ARB = GL_CLIENT_ACTIVE_TEXTURE_ARB
GL_CLIENT_ALL_ATTRIB_BITS = GL_CLIENT_ALL_ATTRIB_BITS
GL_CLIENT_ATTRIB_STACK_DEPTH = GL_CLIENT_ATTRIB_STACK_DEPTH
GL_CLIENT_PIXEL_STORE_BIT = GL_CLIENT_PIXEL_STORE_BIT
GL_CLIENT_VERTEX_ARRAY_BIT = GL_CLIENT_VERTEX_ARRAY_BIT
GL_CLIP_FAR_HINT_PGI = GL_CLIP_FAR_HINT_PGI
GL_CLIP_NEAR_HINT_PGI = GL_CLIP_NEAR_HINT_PGI
GL_CLIP_PLANE0 = GL_CLIP_PLANE0
GL_CLIP_PLANE1 = GL_CLIP_PLANE1
GL_CLIP_PLANE2 = GL_CLIP_PLANE2
GL_CLIP_PLANE3 = GL_CLIP_PLANE3
GL_CLIP_PLANE4 = GL_CLIP_PLANE4
GL_CLIP_PLANE5 = GL_CLIP_PLANE5
GL_CLIP_VOLUME_CLIPPING_HINT_EXT = GL_CLIP_VOLUME_CLIPPING_HINT_EXT
GL_CMYKA_EXT = GL_CMYKA_EXT
GL_CMYK_EXT = GL_CMYK_EXT
GL_CND0_ATI = GL_CND0_ATI
GL_CND_ATI = GL_CND_ATI
GL_COEFF = GL_COEFF
GL_COLOR = GL_COLOR
GL_COLOR3_BIT_PGI = GL_COLOR3_BIT_PGI
GL_COLOR4_BIT_PGI = GL_COLOR4_BIT_PGI
GL_COLOR_ALPHA_PAIRING_ATI = GL_COLOR_ALPHA_PAIRING_ATI
GL_COLOR_ARRAY = GL_COLOR_ARRAY
GL_COLOR_ARRAY_BUFFER_BINDING = GL_COLOR_ARRAY_BUFFER_BINDING
GL_COLOR_ARRAY_BUFFER_BINDING_ARB = GL_COLOR_ARRAY_BUFFER_BINDING_ARB
GL_COLOR_ARRAY_COUNT_EXT = GL_COLOR_ARRAY_COUNT_EXT
GL_COLOR_ARRAY_EXT = GL_COLOR_ARRAY_EXT
GL_COLOR_ARRAY_LIST_IBM = GL_COLOR_ARRAY_LIST_IBM
GL_COLOR_ARRAY_LIST_STRIDE_IBM = GL_COLOR_ARRAY_LIST_STRIDE_IBM
GL_COLOR_ARRAY_PARALLEL_POINTERS_INTEL = GL_COLOR_ARRAY_PARALLEL_POINTERS_INTEL
GL_COLOR_ARRAY_POINTER = GL_COLOR_ARRAY_POINTER
GL_COLOR_ARRAY_POINTER_EXT = GL_COLOR_ARRAY_POINTER_EXT
GL_COLOR_ARRAY_SIZE = GL_COLOR_ARRAY_SIZE
GL_COLOR_ARRAY_SIZE_EXT = GL_COLOR_ARRAY_SIZE_EXT
GL_COLOR_ARRAY_STRIDE = GL_COLOR_ARRAY_STRIDE
GL_COLOR_ARRAY_STRIDE_EXT = GL_COLOR_ARRAY_STRIDE_EXT
GL_COLOR_ARRAY_TYPE = GL_COLOR_ARRAY_TYPE
GL_COLOR_ARRAY_TYPE_EXT = GL_COLOR_ARRAY_TYPE_EXT
GL_COLOR_ATTACHMENT0_EXT = GL_COLOR_ATTACHMENT0_EXT
GL_COLOR_ATTACHMENT10_EXT = GL_COLOR_ATTACHMENT10_EXT
GL_COLOR_ATTACHMENT11_EXT = GL_COLOR_ATTACHMENT11_EXT
GL_COLOR_ATTACHMENT12_EXT = GL_COLOR_ATTACHMENT12_EXT
GL_COLOR_ATTACHMENT13_EXT = GL_COLOR_ATTACHMENT13_EXT
GL_COLOR_ATTACHMENT14_EXT = GL_COLOR_ATTACHMENT14_EXT
GL_COLOR_ATTACHMENT15_EXT = GL_COLOR_ATTACHMENT15_EXT
GL_COLOR_ATTACHMENT1_EXT = GL_COLOR_ATTACHMENT1_EXT
GL_COLOR_ATTACHMENT2_EXT = GL_COLOR_ATTACHMENT2_EXT
GL_COLOR_ATTACHMENT3_EXT = GL_COLOR_ATTACHMENT3_EXT
GL_COLOR_ATTACHMENT4_EXT = GL_COLOR_ATTACHMENT4_EXT
GL_COLOR_ATTACHMENT5_EXT = GL_COLOR_ATTACHMENT5_EXT
GL_COLOR_ATTACHMENT6_EXT = GL_COLOR_ATTACHMENT6_EXT
GL_COLOR_ATTACHMENT7_EXT = GL_COLOR_ATTACHMENT7_EXT
GL_COLOR_ATTACHMENT8_EXT = GL_COLOR_ATTACHMENT8_EXT
GL_COLOR_ATTACHMENT9_EXT = GL_COLOR_ATTACHMENT9_EXT
GL_COLOR_BUFFER_BIT = GL_COLOR_BUFFER_BIT
GL_COLOR_CLEAR_UNCLAMPED_VALUE_ATI = GL_COLOR_CLEAR_UNCLAMPED_VALUE_ATI
GL_COLOR_CLEAR_VALUE = GL_COLOR_CLEAR_VALUE
GL_COLOR_INDEX = GL_COLOR_INDEX
GL_COLOR_INDEX12_EXT = GL_COLOR_INDEX12_EXT
GL_COLOR_INDEX16_EXT = GL_COLOR_INDEX16_EXT
GL_COLOR_INDEX1_EXT = GL_COLOR_INDEX1_EXT
GL_COLOR_INDEX2_EXT = GL_COLOR_INDEX2_EXT
GL_COLOR_INDEX4_EXT = GL_COLOR_INDEX4_EXT
GL_COLOR_INDEX8_EXT = GL_COLOR_INDEX8_EXT
GL_COLOR_INDEXES = GL_COLOR_INDEXES
GL_COLOR_LOGIC_OP = GL_COLOR_LOGIC_OP
GL_COLOR_MATERIAL = GL_COLOR_MATERIAL
GL_COLOR_MATERIAL_FACE = GL_COLOR_MATERIAL_FACE
GL_COLOR_MATERIAL_PARAMETER = GL_COLOR_MATERIAL_PARAMETER
GL_COLOR_MATRIX = GL_COLOR_MATRIX
GL_COLOR_MATRIX_SGI = GL_COLOR_MATRIX_SGI
GL_COLOR_MATRIX_STACK_DEPTH = GL_COLOR_MATRIX_STACK_DEPTH
GL_COLOR_MATRIX_STACK_DEPTH_SGI = GL_COLOR_MATRIX_STACK_DEPTH_SGI
GL_COLOR_SUM = GL_COLOR_SUM
GL_COLOR_SUM_ARB = GL_COLOR_SUM_ARB
GL_COLOR_SUM_CLAMP_NV = GL_COLOR_SUM_CLAMP_NV
GL_COLOR_SUM_EXT = GL_COLOR_SUM_EXT
GL_COLOR_TABLE = GL_COLOR_TABLE
GL_COLOR_TABLE_ALPHA_SIZE = GL_COLOR_TABLE_ALPHA_SIZE
GL_COLOR_TABLE_ALPHA_SIZE_SGI = GL_COLOR_TABLE_ALPHA_SIZE_SGI
GL_COLOR_TABLE_BIAS = GL_COLOR_TABLE_BIAS
GL_COLOR_TABLE_BIAS_SGI = GL_COLOR_TABLE_BIAS_SGI
GL_COLOR_TABLE_BLUE_SIZE = GL_COLOR_TABLE_BLUE_SIZE
GL_COLOR_TABLE_BLUE_SIZE_SGI = GL_COLOR_TABLE_BLUE_SIZE_SGI
GL_COLOR_TABLE_FORMAT = GL_COLOR_TABLE_FORMAT
GL_COLOR_TABLE_FORMAT_SGI = GL_COLOR_TABLE_FORMAT_SGI
GL_COLOR_TABLE_GREEN_SIZE = GL_COLOR_TABLE_GREEN_SIZE
GL_COLOR_TABLE_GREEN_SIZE_SGI = GL_COLOR_TABLE_GREEN_SIZE_SGI
GL_COLOR_TABLE_INTENSITY_SIZE = GL_COLOR_TABLE_INTENSITY_SIZE
GL_COLOR_TABLE_INTENSITY_SIZE_SGI = GL_COLOR_TABLE_INTENSITY_SIZE_SGI
GL_COLOR_TABLE_LUMINANCE_SIZE = GL_COLOR_TABLE_LUMINANCE_SIZE
GL_COLOR_TABLE_LUMINANCE_SIZE_SGI = GL_COLOR_TABLE_LUMINANCE_SIZE_SGI
GL_COLOR_TABLE_RED_SIZE = GL_COLOR_TABLE_RED_SIZE
GL_COLOR_TABLE_RED_SIZE_SGI = GL_COLOR_TABLE_RED_SIZE_SGI
GL_COLOR_TABLE_SCALE = GL_COLOR_TABLE_SCALE
GL_COLOR_TABLE_SCALE_SGI = GL_COLOR_TABLE_SCALE_SGI
GL_COLOR_TABLE_SGI = GL_COLOR_TABLE_SGI
GL_COLOR_TABLE_WIDTH = GL_COLOR_TABLE_WIDTH
GL_COLOR_TABLE_WIDTH_SGI = GL_COLOR_TABLE_WIDTH_SGI
GL_COLOR_WRITEMASK = GL_COLOR_WRITEMASK
GL_COMBINE = GL_COMBINE
GL_COMBINE4_NV = GL_COMBINE4_NV
GL_COMBINER0_NV = GL_COMBINER0_NV
GL_COMBINER1_NV = GL_COMBINER1_NV
GL_COMBINER2_NV = GL_COMBINER2_NV
GL_COMBINER3_NV = GL_COMBINER3_NV
GL_COMBINER4_NV = GL_COMBINER4_NV
GL_COMBINER5_NV = GL_COMBINER5_NV
GL_COMBINER6_NV = GL_COMBINER6_NV
GL_COMBINER7_NV = GL_COMBINER7_NV
GL_COMBINER_AB_DOT_PRODUCT_NV = GL_COMBINER_AB_DOT_PRODUCT_NV
GL_COMBINER_AB_OUTPUT_NV = GL_COMBINER_AB_OUTPUT_NV
GL_COMBINER_BIAS_NV = GL_COMBINER_BIAS_NV
GL_COMBINER_CD_DOT_PRODUCT_NV = GL_COMBINER_CD_DOT_PRODUCT_NV
GL_COMBINER_CD_OUTPUT_NV = GL_COMBINER_CD_OUTPUT_NV
GL_COMBINER_COMPONENT_USAGE_NV = GL_COMBINER_COMPONENT_USAGE_NV
GL_COMBINER_INPUT_NV = GL_COMBINER_INPUT_NV
GL_COMBINER_MAPPING_NV = GL_COMBINER_MAPPING_NV
GL_COMBINER_MUX_SUM_NV = GL_COMBINER_MUX_SUM_NV
GL_COMBINER_SCALE_NV = GL_COMBINER_SCALE_NV
GL_COMBINER_SUM_OUTPUT_NV = GL_COMBINER_SUM_OUTPUT_NV
GL_COMBINE_ALPHA = GL_COMBINE_ALPHA
GL_COMBINE_ALPHA_ARB = GL_COMBINE_ALPHA_ARB
GL_COMBINE_ALPHA_EXT = GL_COMBINE_ALPHA_EXT
GL_COMBINE_ARB = GL_COMBINE_ARB
GL_COMBINE_EXT = GL_COMBINE_EXT
GL_COMBINE_RGB = GL_COMBINE_RGB
GL_COMBINE_RGB_ARB = GL_COMBINE_RGB_ARB
GL_COMBINE_RGB_EXT = GL_COMBINE_RGB_EXT
GL_COMPARE_R_TO_TEXTURE = GL_COMPARE_R_TO_TEXTURE
GL_COMPARE_R_TO_TEXTURE_ARB = GL_COMPARE_R_TO_TEXTURE_ARB
GL_COMPILE = GL_COMPILE
GL_COMPILE_AND_EXECUTE = GL_COMPILE_AND_EXECUTE
GL_COMPILE_STATUS = GL_COMPILE_STATUS
GL_COMPRESSED_ALPHA = GL_COMPRESSED_ALPHA
GL_COMPRESSED_ALPHA_ARB = GL_COMPRESSED_ALPHA_ARB
GL_COMPRESSED_INTENSITY = GL_COMPRESSED_INTENSITY
GL_COMPRESSED_INTENSITY_ARB = GL_COMPRESSED_INTENSITY_ARB
GL_COMPRESSED_LUMINANCE = GL_COMPRESSED_LUMINANCE
GL_COMPRESSED_LUMINANCE_ALPHA = GL_COMPRESSED_LUMINANCE_ALPHA
GL_COMPRESSED_LUMINANCE_ALPHA_ARB = GL_COMPRESSED_LUMINANCE_ALPHA_ARB
GL_COMPRESSED_LUMINANCE_ARB = GL_COMPRESSED_LUMINANCE_ARB
GL_COMPRESSED_RGB = GL_COMPRESSED_RGB
GL_COMPRESSED_RGBA = GL_COMPRESSED_RGBA
GL_COMPRESSED_RGBA_ARB = GL_COMPRESSED_RGBA_ARB
GL_COMPRESSED_RGBA_FXT1_3DFX = GL_COMPRESSED_RGBA_FXT1_3DFX
GL_COMPRESSED_RGBA_S3TC_DXT1_EXT = GL_COMPRESSED_RGBA_S3TC_DXT1_EXT
GL_COMPRESSED_RGBA_S3TC_DXT3_EXT = GL_COMPRESSED_RGBA_S3TC_DXT3_EXT
GL_COMPRESSED_RGBA_S3TC_DXT5_EXT = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT
GL_COMPRESSED_RGB_ARB = GL_COMPRESSED_RGB_ARB
GL_COMPRESSED_RGB_FXT1_3DFX = GL_COMPRESSED_RGB_FXT1_3DFX
GL_COMPRESSED_RGB_S3TC_DXT1_EXT = GL_COMPRESSED_RGB_S3TC_DXT1_EXT
GL_COMPRESSED_SLUMINANCE = GL_COMPRESSED_SLUMINANCE
GL_COMPRESSED_SLUMINANCE_ALPHA = GL_COMPRESSED_SLUMINANCE_ALPHA
GL_COMPRESSED_SRGB = GL_COMPRESSED_SRGB
GL_COMPRESSED_SRGB_ALPHA = GL_COMPRESSED_SRGB_ALPHA
GL_COMPRESSED_TEXTURE_FORMATS = GL_COMPRESSED_TEXTURE_FORMATS
GL_COMPRESSED_TEXTURE_FORMATS_ARB = GL_COMPRESSED_TEXTURE_FORMATS_ARB
GL_COMP_BIT_ATI = GL_COMP_BIT_ATI
GL_CONSERVE_MEMORY_HINT_PGI = GL_CONSERVE_MEMORY_HINT_PGI
GL_CONSTANT = GL_CONSTANT
GL_CONSTANT_ALPHA = GL_CONSTANT_ALPHA
GL_CONSTANT_ALPHA_EXT = GL_CONSTANT_ALPHA_EXT
GL_CONSTANT_ARB = GL_CONSTANT_ARB
GL_CONSTANT_ATTENUATION = GL_CONSTANT_ATTENUATION
GL_CONSTANT_BORDER = GL_CONSTANT_BORDER
GL_CONSTANT_BORDER_HP = GL_CONSTANT_BORDER_HP
GL_CONSTANT_COLOR = GL_CONSTANT_COLOR
GL_CONSTANT_COLOR0_NV = GL_CONSTANT_COLOR0_NV
GL_CONSTANT_COLOR1_NV = GL_CONSTANT_COLOR1_NV
GL_CONSTANT_COLOR_EXT = GL_CONSTANT_COLOR_EXT
GL_CONSTANT_EXT = GL_CONSTANT_EXT
GL_CONST_EYE_NV = GL_CONST_EYE_NV
GL_CONVOLUTION_1D = GL_CONVOLUTION_1D
GL_CONVOLUTION_1D_EXT = GL_CONVOLUTION_1D_EXT
GL_CONVOLUTION_2D = GL_CONVOLUTION_2D
GL_CONVOLUTION_2D_EXT = GL_CONVOLUTION_2D_EXT
GL_CONVOLUTION_BORDER_COLOR = GL_CONVOLUTION_BORDER_COLOR
GL_CONVOLUTION_BORDER_COLOR_HP = GL_CONVOLUTION_BORDER_COLOR_HP
GL_CONVOLUTION_BORDER_MODE = GL_CONVOLUTION_BORDER_MODE
GL_CONVOLUTION_BORDER_MODE_EXT = GL_CONVOLUTION_BORDER_MODE_EXT
GL_CONVOLUTION_FILTER_BIAS = GL_CONVOLUTION_FILTER_BIAS
GL_CONVOLUTION_FILTER_BIAS_EXT = GL_CONVOLUTION_FILTER_BIAS_EXT
GL_CONVOLUTION_FILTER_SCALE = GL_CONVOLUTION_FILTER_SCALE
GL_CONVOLUTION_FILTER_SCALE_EXT = GL_CONVOLUTION_FILTER_SCALE_EXT
GL_CONVOLUTION_FORMAT = GL_CONVOLUTION_FORMAT
GL_CONVOLUTION_FORMAT_EXT = GL_CONVOLUTION_FORMAT_EXT
GL_CONVOLUTION_HEIGHT = GL_CONVOLUTION_HEIGHT
GL_CONVOLUTION_HEIGHT_EXT = GL_CONVOLUTION_HEIGHT_EXT
GL_CONVOLUTION_HINT_SGIX = GL_CONVOLUTION_HINT_SGIX
GL_CONVOLUTION_WIDTH = GL_CONVOLUTION_WIDTH
GL_CONVOLUTION_WIDTH_EXT = GL_CONVOLUTION_WIDTH_EXT
GL_CON_0_ATI = GL_CON_0_ATI
GL_CON_10_ATI = GL_CON_10_ATI
GL_CON_11_ATI = GL_CON_11_ATI
GL_CON_12_ATI = GL_CON_12_ATI
GL_CON_13_ATI = GL_CON_13_ATI
GL_CON_14_ATI = GL_CON_14_ATI
GL_CON_15_ATI = GL_CON_15_ATI
GL_CON_16_ATI = GL_CON_16_ATI
GL_CON_17_ATI = GL_CON_17_ATI
GL_CON_18_ATI = GL_CON_18_ATI
GL_CON_19_ATI = GL_CON_19_ATI
GL_CON_1_ATI = GL_CON_1_ATI
GL_CON_20_ATI = GL_CON_20_ATI
GL_CON_21_ATI = GL_CON_21_ATI
GL_CON_22_ATI = GL_CON_22_ATI
GL_CON_23_ATI = GL_CON_23_ATI
GL_CON_24_ATI = GL_CON_24_ATI
GL_CON_25_ATI = GL_CON_25_ATI
GL_CON_26_ATI = GL_CON_26_ATI
GL_CON_27_ATI = GL_CON_27_ATI
GL_CON_28_ATI = GL_CON_28_ATI
GL_CON_29_ATI = GL_CON_29_ATI
GL_CON_2_ATI = GL_CON_2_ATI
GL_CON_30_ATI = GL_CON_30_ATI
GL_CON_31_ATI = GL_CON_31_ATI
GL_CON_3_ATI = GL_CON_3_ATI
GL_CON_4_ATI = GL_CON_4_ATI
GL_CON_5_ATI = GL_CON_5_ATI
GL_CON_6_ATI = GL_CON_6_ATI
GL_CON_7_ATI = GL_CON_7_ATI
GL_CON_8_ATI = GL_CON_8_ATI
GL_CON_9_ATI = GL_CON_9_ATI
GL_COORD_REPLACE = GL_COORD_REPLACE
GL_COORD_REPLACE_ARB = GL_COORD_REPLACE_ARB
GL_COORD_REPLACE_NV = GL_COORD_REPLACE_NV
GL_COPY = GL_COPY
GL_COPY_INVERTED = GL_COPY_INVERTED
GL_COPY_PIXEL_TOKEN = GL_COPY_PIXEL_TOKEN
GL_CUBIC_EXT = GL_CUBIC_EXT
GL_CUBIC_HP = GL_CUBIC_HP
GL_CULL_FACE = GL_CULL_FACE
GL_CULL_FACE_MODE = GL_CULL_FACE_MODE
GL_CULL_FRAGMENT_NV = GL_CULL_FRAGMENT_NV
GL_CULL_MODES_NV = GL_CULL_MODES_NV
GL_CULL_VERTEX_EXT = GL_CULL_VERTEX_EXT
GL_CULL_VERTEX_EYE_POSITION_EXT = GL_CULL_VERTEX_EYE_POSITION_EXT
GL_CULL_VERTEX_IBM = GL_CULL_VERTEX_IBM
GL_CULL_VERTEX_OBJECT_POSITION_EXT = GL_CULL_VERTEX_OBJECT_POSITION_EXT
GL_CURRENT_ATTRIB_NV = GL_CURRENT_ATTRIB_NV
GL_CURRENT_BINORMAL_EXT = GL_CURRENT_BINORMAL_EXT
GL_CURRENT_BIT = GL_CURRENT_BIT
GL_CURRENT_COLOR = GL_CURRENT_COLOR
GL_CURRENT_FOG_COORD = GL_CURRENT_FOG_COORDINATE
GL_CURRENT_FOG_COORDINATE = GL_CURRENT_FOG_COORDINATE
GL_CURRENT_FOG_COORDINATE_EXT = GL_CURRENT_FOG_COORDINATE_EXT
GL_CURRENT_INDEX = GL_CURRENT_INDEX
GL_CURRENT_MATRIX_ARB = GL_CURRENT_MATRIX_ARB
GL_CURRENT_MATRIX_INDEX_ARB = GL_CURRENT_MATRIX_INDEX_ARB
GL_CURRENT_MATRIX_NV = GL_CURRENT_MATRIX_NV
GL_CURRENT_MATRIX_STACK_DEPTH_ARB = GL_CURRENT_MATRIX_STACK_DEPTH_ARB
GL_CURRENT_MATRIX_STACK_DEPTH_NV = GL_CURRENT_MATRIX_STACK_DEPTH_NV
GL_CURRENT_NORMAL = GL_CURRENT_NORMAL
GL_CURRENT_OCCLUSION_QUERY_ID_NV = GL_CURRENT_OCCLUSION_QUERY_ID_NV
GL_CURRENT_PALETTE_MATRIX_ARB = GL_CURRENT_PALETTE_MATRIX_ARB
GL_CURRENT_PROGRAM = GL_CURRENT_PROGRAM
GL_CURRENT_QUERY = GL_CURRENT_QUERY
GL_CURRENT_QUERY_ARB = GL_CURRENT_QUERY_ARB
GL_CURRENT_RASTER_COLOR = GL_CURRENT_RASTER_COLOR
GL_CURRENT_RASTER_DISTANCE = GL_CURRENT_RASTER_DISTANCE
GL_CURRENT_RASTER_INDEX = GL_CURRENT_RASTER_INDEX
GL_CURRENT_RASTER_NORMAL_SGIX = GL_CURRENT_RASTER_NORMAL_SGIX
GL_CURRENT_RASTER_POSITION = GL_CURRENT_RASTER_POSITION
GL_CURRENT_RASTER_POSITION_VALID = GL_CURRENT_RASTER_POSITION_VALID
GL_CURRENT_RASTER_SECONDARY_COLOR = GL_CURRENT_RASTER_SECONDARY_COLOR
GL_CURRENT_RASTER_TEXTURE_COORDS = GL_CURRENT_RASTER_TEXTURE_COORDS
GL_CURRENT_SECONDARY_COLOR = GL_CURRENT_SECONDARY_COLOR
GL_CURRENT_SECONDARY_COLOR_EXT = GL_CURRENT_SECONDARY_COLOR_EXT
GL_CURRENT_TANGENT_EXT = GL_CURRENT_TANGENT_EXT
GL_CURRENT_TEXTURE_COORDS = GL_CURRENT_TEXTURE_COORDS
GL_CURRENT_VERTEX_ATTRIB = GL_CURRENT_VERTEX_ATTRIB
GL_CURRENT_VERTEX_ATTRIB_ARB = GL_CURRENT_VERTEX_ATTRIB_ARB
GL_CURRENT_VERTEX_EXT = GL_CURRENT_VERTEX_EXT
GL_CURRENT_VERTEX_WEIGHT_EXT = GL_CURRENT_VERTEX_WEIGHT_EXT
GL_CURRENT_WEIGHT_ARB = GL_CURRENT_WEIGHT_ARB
GL_CW = GL_CW
GL_DECAL = GL_DECAL
GL_DECR = GL_DECR
GL_DECR_WRAP = GL_DECR_WRAP
GL_DECR_WRAP_EXT = GL_DECR_WRAP_EXT
GL_DEFORMATIONS_MASK_SGIX = GL_DEFORMATIONS_MASK_SGIX
GL_DELETE_STATUS = GL_DELETE_STATUS
GL_DEPENDENT_AR_TEXTURE_2D_NV = GL_DEPENDENT_AR_TEXTURE_2D_NV
GL_DEPENDENT_GB_TEXTURE_2D_NV = GL_DEPENDENT_GB_TEXTURE_2D_NV
GL_DEPENDENT_HILO_TEXTURE_2D_NV = GL_DEPENDENT_HILO_TEXTURE_2D_NV
GL_DEPENDENT_RGB_TEXTURE_3D_NV = GL_DEPENDENT_RGB_TEXTURE_3D_NV
GL_DEPENDENT_RGB_TEXTURE_CUBE_MAP_NV = GL_DEPENDENT_RGB_TEXTURE_CUBE_MAP_NV
GL_DEPTH = GL_DEPTH
GL_DEPTH_ATTACHMENT_EXT = GL_DEPTH_ATTACHMENT_EXT
GL_DEPTH_BIAS = GL_DEPTH_BIAS
GL_DEPTH_BITS = GL_DEPTH_BITS
GL_DEPTH_BOUNDS_EXT = GL_DEPTH_BOUNDS_EXT
GL_DEPTH_BOUNDS_TEST_EXT = GL_DEPTH_BOUNDS_TEST_EXT
GL_DEPTH_BUFFER_BIT = GL_DEPTH_BUFFER_BIT
GL_DEPTH_CLAMP_NV = GL_DEPTH_CLAMP_NV
GL_DEPTH_CLEAR_VALUE = GL_DEPTH_CLEAR_VALUE
GL_DEPTH_COMPONENT = GL_DEPTH_COMPONENT
GL_DEPTH_COMPONENT16 = GL_DEPTH_COMPONENT16
GL_DEPTH_COMPONENT16_ARB = GL_DEPTH_COMPONENT16_ARB
GL_DEPTH_COMPONENT16_SGIX = GL_DEPTH_COMPONENT16_SGIX
GL_DEPTH_COMPONENT24 = GL_DEPTH_COMPONENT24
GL_DEPTH_COMPONENT24_ARB = GL_DEPTH_COMPONENT24_ARB
GL_DEPTH_COMPONENT24_SGIX = GL_DEPTH_COMPONENT24_SGIX
GL_DEPTH_COMPONENT32 = GL_DEPTH_COMPONENT32
GL_DEPTH_COMPONENT32_ARB = GL_DEPTH_COMPONENT32_ARB
GL_DEPTH_COMPONENT32_SGIX = GL_DEPTH_COMPONENT32_SGIX
GL_DEPTH_FUNC = GL_DEPTH_FUNC
GL_DEPTH_PASS_INSTRUMENT_COUNTERS_SGIX = GL_DEPTH_PASS_INSTRUMENT_COUNTERS_SGIX
GL_DEPTH_PASS_INSTRUMENT_MAX_SGIX = GL_DEPTH_PASS_INSTRUMENT_MAX_SGIX
GL_DEPTH_PASS_INSTRUMENT_SGIX = GL_DEPTH_PASS_INSTRUMENT_SGIX
GL_DEPTH_RANGE = GL_DEPTH_RANGE
GL_DEPTH_SCALE = GL_DEPTH_SCALE
GL_DEPTH_STENCIL_NV = GL_DEPTH_STENCIL_NV
GL_DEPTH_STENCIL_TO_BGRA_NV = GL_DEPTH_STENCIL_TO_BGRA_NV
GL_DEPTH_STENCIL_TO_RGBA_NV = GL_DEPTH_STENCIL_TO_RGBA_NV
GL_DEPTH_TEST = GL_DEPTH_TEST
GL_DEPTH_TEXTURE_MODE = GL_DEPTH_TEXTURE_MODE
GL_DEPTH_TEXTURE_MODE_ARB = GL_DEPTH_TEXTURE_MODE_ARB
GL_DEPTH_WRITEMASK = GL_DEPTH_WRITEMASK
GL_DETAIL_TEXTURE_2D_BINDING_SGIS = GL_DETAIL_TEXTURE_2D_BINDING_SGIS
GL_DETAIL_TEXTURE_2D_SGIS = GL_DETAIL_TEXTURE_2D_SGIS
GL_DETAIL_TEXTURE_FUNC_POINTS_SGIS = GL_DETAIL_TEXTURE_FUNC_POINTS_SGIS
GL_DETAIL_TEXTURE_LEVEL_SGIS = GL_DETAIL_TEXTURE_LEVEL_SGIS
GL_DETAIL_TEXTURE_MODE_SGIS = GL_DETAIL_TEXTURE_MODE_SGIS
GL_DIFFUSE = GL_DIFFUSE
GL_DISCARD_ATI = GL_DISCARD_ATI
GL_DISCARD_NV = GL_DISCARD_NV
GL_DISTANCE_ATTENUATION_EXT = GL_DISTANCE_ATTENUATION_EXT
GL_DISTANCE_ATTENUATION_SGIS = GL_DISTANCE_ATTENUATION_SGIS
GL_DITHER = GL_DITHER
GL_DOMAIN = GL_DOMAIN
GL_DONT_CARE = GL_DONT_CARE
GL_DOT2_ADD_ATI = GL_DOT2_ADD_ATI
GL_DOT3_ATI = GL_DOT3_ATI
GL_DOT3_RGB = GL_DOT3_RGB
GL_DOT3_RGBA = GL_DOT3_RGBA
GL_DOT3_RGBA_ARB = GL_DOT3_RGBA_ARB
GL_DOT3_RGBA_EXT = GL_DOT3_RGBA_EXT
GL_DOT3_RGB_ARB = GL_DOT3_RGB_ARB
GL_DOT3_RGB_EXT = GL_DOT3_RGB_EXT
GL_DOT4_ATI = GL_DOT4_ATI
GL_DOT_PRODUCT_AFFINE_DEPTH_REPLACE_NV = GL_DOT_PRODUCT_AFFINE_DEPTH_REPLACE_NV
GL_DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV = GL_DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV
GL_DOT_PRODUCT_DEPTH_REPLACE_NV = GL_DOT_PRODUCT_DEPTH_REPLACE_NV
GL_DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV = GL_DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV
GL_DOT_PRODUCT_NV = GL_DOT_PRODUCT_NV
GL_DOT_PRODUCT_PASS_THROUGH_NV = GL_DOT_PRODUCT_PASS_THROUGH_NV
GL_DOT_PRODUCT_REFLECT_CUBE_MAP_NV = GL_DOT_PRODUCT_REFLECT_CUBE_MAP_NV
GL_DOT_PRODUCT_TEXTURE_1D_NV = GL_DOT_PRODUCT_TEXTURE_1D_NV
GL_DOT_PRODUCT_TEXTURE_2D_NV = GL_DOT_PRODUCT_TEXTURE_2D_NV
GL_DOT_PRODUCT_TEXTURE_3D_NV = GL_DOT_PRODUCT_TEXTURE_3D_NV
GL_DOT_PRODUCT_TEXTURE_CUBE_MAP_NV = GL_DOT_PRODUCT_TEXTURE_CUBE_MAP_NV
GL_DOT_PRODUCT_TEXTURE_RECTANGLE_NV = GL_DOT_PRODUCT_TEXTURE_RECTANGLE_NV
GL_DOUBLE = GL_DOUBLE
GL_DOUBLEBUFFER = GL_DOUBLEBUFFER
GL_DOUBLE_EXT = GL_DOUBLE_EXT
GL_DRAW_BUFFER = GL_DRAW_BUFFER
GL_DRAW_BUFFER0 = GL_DRAW_BUFFER0
GL_DRAW_BUFFER0_ARB = GL_DRAW_BUFFER0_ARB
GL_DRAW_BUFFER0_ATI = GL_DRAW_BUFFER0_ATI
GL_DRAW_BUFFER1 = GL_DRAW_BUFFER1
GL_DRAW_BUFFER10 = GL_DRAW_BUFFER10
GL_DRAW_BUFFER10_ARB = GL_DRAW_BUFFER10_ARB
GL_DRAW_BUFFER10_ATI = GL_DRAW_BUFFER10_ATI
GL_DRAW_BUFFER11 = GL_DRAW_BUFFER11
GL_DRAW_BUFFER11_ARB = GL_DRAW_BUFFER11_ARB
GL_DRAW_BUFFER11_ATI = GL_DRAW_BUFFER11_ATI
GL_DRAW_BUFFER12 = GL_DRAW_BUFFER12
GL_DRAW_BUFFER12_ARB = GL_DRAW_BUFFER12_ARB
GL_DRAW_BUFFER12_ATI = GL_DRAW_BUFFER12_ATI
GL_DRAW_BUFFER13 = GL_DRAW_BUFFER13
GL_DRAW_BUFFER13_ARB = GL_DRAW_BUFFER13_ARB
GL_DRAW_BUFFER13_ATI = GL_DRAW_BUFFER13_ATI
GL_DRAW_BUFFER14 = GL_DRAW_BUFFER14
GL_DRAW_BUFFER14_ARB = GL_DRAW_BUFFER14_ARB
GL_DRAW_BUFFER14_ATI = GL_DRAW_BUFFER14_ATI
GL_DRAW_BUFFER15 = GL_DRAW_BUFFER15
GL_DRAW_BUFFER15_ARB = GL_DRAW_BUFFER15_ARB
GL_DRAW_BUFFER15_ATI = GL_DRAW_BUFFER15_ATI
GL_DRAW_BUFFER1_ARB = GL_DRAW_BUFFER1_ARB
GL_DRAW_BUFFER1_ATI = GL_DRAW_BUFFER1_ATI
GL_DRAW_BUFFER2 = GL_DRAW_BUFFER2
GL_DRAW_BUFFER2_ARB = GL_DRAW_BUFFER2_ARB
GL_DRAW_BUFFER2_ATI = GL_DRAW_BUFFER2_ATI
GL_DRAW_BUFFER3 = GL_DRAW_BUFFER3
GL_DRAW_BUFFER3_ARB = GL_DRAW_BUFFER3_ARB
GL_DRAW_BUFFER3_ATI = GL_DRAW_BUFFER3_ATI
GL_DRAW_BUFFER4 = GL_DRAW_BUFFER4
GL_DRAW_BUFFER4_ARB = GL_DRAW_BUFFER4_ARB
GL_DRAW_BUFFER4_ATI = GL_DRAW_BUFFER4_ATI
GL_DRAW_BUFFER5 = GL_DRAW_BUFFER5
GL_DRAW_BUFFER5_ARB = GL_DRAW_BUFFER5_ARB
GL_DRAW_BUFFER5_ATI = GL_DRAW_BUFFER5_ATI
GL_DRAW_BUFFER6 = GL_DRAW_BUFFER6
GL_DRAW_BUFFER6_ARB = GL_DRAW_BUFFER6_ARB
GL_DRAW_BUFFER6_ATI = GL_DRAW_BUFFER6_ATI
GL_DRAW_BUFFER7 = GL_DRAW_BUFFER7
GL_DRAW_BUFFER7_ARB = GL_DRAW_BUFFER7_ARB
GL_DRAW_BUFFER7_ATI = GL_DRAW_BUFFER7_ATI
GL_DRAW_BUFFER8 = GL_DRAW_BUFFER8
GL_DRAW_BUFFER8_ARB = GL_DRAW_BUFFER8_ARB
GL_DRAW_BUFFER8_ATI = GL_DRAW_BUFFER8_ATI
GL_DRAW_BUFFER9 = GL_DRAW_BUFFER9
GL_DRAW_BUFFER9_ARB = GL_DRAW_BUFFER9_ARB
GL_DRAW_BUFFER9_ATI = GL_DRAW_BUFFER9_ATI
GL_DRAW_PIXELS_APPLE = GL_DRAW_PIXELS_APPLE
GL_DRAW_PIXEL_TOKEN = GL_DRAW_PIXEL_TOKEN
GL_DSDT8_MAG8_INTENSITY8_NV = GL_DSDT8_MAG8_INTENSITY8_NV
GL_DSDT8_MAG8_NV = GL_DSDT8_MAG8_NV
GL_DSDT8_NV = GL_DSDT8_NV
GL_DSDT_MAG_INTENSITY_NV = GL_DSDT_MAG_INTENSITY_NV
GL_DSDT_MAG_NV = GL_DSDT_MAG_NV
GL_DSDT_MAG_VIB_NV = GL_DSDT_MAG_VIB_NV
GL_DSDT_NV = GL_DSDT_NV
GL_DST_ALPHA = GL_DST_ALPHA
GL_DST_COLOR = GL_DST_COLOR
GL_DS_BIAS_NV = GL_DS_BIAS_NV
GL_DS_SCALE_NV = GL_DS_SCALE_NV
GL_DT_BIAS_NV = GL_DT_BIAS_NV
GL_DT_SCALE_NV = GL_DT_SCALE_NV
GL_DU8DV8_ATI = GL_DU8DV8_ATI
GL_DUAL_ALPHA12_SGIS = GL_DUAL_ALPHA12_SGIS
GL_DUAL_ALPHA16_SGIS = GL_DUAL_ALPHA16_SGIS
GL_DUAL_ALPHA4_SGIS = GL_DUAL_ALPHA4_SGIS
GL_DUAL_ALPHA8_SGIS = GL_DUAL_ALPHA8_SGIS
GL_DUAL_INTENSITY12_SGIS = GL_DUAL_INTENSITY12_SGIS
GL_DUAL_INTENSITY16_SGIS = GL_DUAL_INTENSITY16_SGIS
GL_DUAL_INTENSITY4_SGIS = GL_DUAL_INTENSITY4_SGIS
GL_DUAL_INTENSITY8_SGIS = GL_DUAL_INTENSITY8_SGIS
GL_DUAL_LUMINANCE12_SGIS = GL_DUAL_LUMINANCE12_SGIS
GL_DUAL_LUMINANCE16_SGIS = GL_DUAL_LUMINANCE16_SGIS
GL_DUAL_LUMINANCE4_SGIS = GL_DUAL_LUMINANCE4_SGIS
GL_DUAL_LUMINANCE8_SGIS = GL_DUAL_LUMINANCE8_SGIS
GL_DUAL_LUMINANCE_ALPHA4_SGIS = GL_DUAL_LUMINANCE_ALPHA4_SGIS
GL_DUAL_LUMINANCE_ALPHA8_SGIS = GL_DUAL_LUMINANCE_ALPHA8_SGIS
GL_DUAL_TEXTURE_SELECT_SGIS = GL_DUAL_TEXTURE_SELECT_SGIS
GL_DUDV_ATI = GL_DUDV_ATI
GL_DYNAMIC_ATI = GL_DYNAMIC_ATI
GL_DYNAMIC_COPY = GL_DYNAMIC_COPY
GL_DYNAMIC_COPY_ARB = GL_DYNAMIC_COPY_ARB
GL_DYNAMIC_DRAW = GL_DYNAMIC_DRAW
GL_DYNAMIC_DRAW_ARB = GL_DYNAMIC_DRAW_ARB
GL_DYNAMIC_READ = GL_DYNAMIC_READ
GL_DYNAMIC_READ_ARB = GL_DYNAMIC_READ_ARB
GL_EDGEFLAG_BIT_PGI = GL_EDGEFLAG_BIT_PGI
GL_EDGE_FLAG = GL_EDGE_FLAG
GL_EDGE_FLAG_ARRAY = GL_EDGE_FLAG_ARRAY
GL_EDGE_FLAG_ARRAY_BUFFER_BINDING = GL_EDGE_FLAG_ARRAY_BUFFER_BINDING
GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB = GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB
GL_EDGE_FLAG_ARRAY_COUNT_EXT = GL_EDGE_FLAG_ARRAY_COUNT_EXT
GL_EDGE_FLAG_ARRAY_EXT = GL_EDGE_FLAG_ARRAY_EXT
GL_EDGE_FLAG_ARRAY_LIST_IBM = GL_EDGE_FLAG_ARRAY_LIST_IBM
GL_EDGE_FLAG_ARRAY_LIST_STRIDE_IBM = GL_EDGE_FLAG_ARRAY_LIST_STRIDE_IBM
GL_EDGE_FLAG_ARRAY_POINTER = GL_EDGE_FLAG_ARRAY_POINTER
GL_EDGE_FLAG_ARRAY_POINTER_EXT = GL_EDGE_FLAG_ARRAY_POINTER_EXT
GL_EDGE_FLAG_ARRAY_STRIDE = GL_EDGE_FLAG_ARRAY_STRIDE
GL_EDGE_FLAG_ARRAY_STRIDE_EXT = GL_EDGE_FLAG_ARRAY_STRIDE_EXT
GL_EIGHTH_BIT_ATI = GL_EIGHTH_BIT_ATI
GL_ELEMENT_ARRAY_APPLE = GL_ELEMENT_ARRAY_APPLE
GL_ELEMENT_ARRAY_ATI = GL_ELEMENT_ARRAY_ATI
GL_ELEMENT_ARRAY_BUFFER = GL_ELEMENT_ARRAY_BUFFER
GL_ELEMENT_ARRAY_BUFFER_ARB = GL_ELEMENT_ARRAY_BUFFER_ARB
GL_ELEMENT_ARRAY_BUFFER_BINDING = GL_ELEMENT_ARRAY_BUFFER_BINDING
GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB = GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB
GL_ELEMENT_ARRAY_POINTER_APPLE = GL_ELEMENT_ARRAY_POINTER_APPLE
GL_ELEMENT_ARRAY_POINTER_ATI = GL_ELEMENT_ARRAY_POINTER_ATI
GL_ELEMENT_ARRAY_TYPE_APPLE = GL_ELEMENT_ARRAY_TYPE_APPLE
GL_ELEMENT_ARRAY_TYPE_ATI = GL_ELEMENT_ARRAY_TYPE_ATI
GL_EMBOSS_CONSTANT_NV = GL_EMBOSS_CONSTANT_NV
GL_EMBOSS_LIGHT_NV = GL_EMBOSS_LIGHT_NV
GL_EMBOSS_MAP_NV = GL_EMBOSS_MAP_NV
GL_EMISSION = GL_EMISSION
GL_ENABLE_BIT = GL_ENABLE_BIT
GL_EQUAL = GL_EQUAL
GL_EQUIV = GL_EQUIV
GL_EVAL_2D_NV = GL_EVAL_2D_NV
GL_EVAL_BIT = GL_EVAL_BIT
GL_EVAL_FRACTIONAL_TESSELLATION_NV = GL_EVAL_FRACTIONAL_TESSELLATION_NV
GL_EVAL_TRIANGULAR_2D_NV = GL_EVAL_TRIANGULAR_2D_NV
GL_EVAL_VERTEX_ATTRIB0_NV = GL_EVAL_VERTEX_ATTRIB0_NV
GL_EVAL_VERTEX_ATTRIB10_NV = GL_EVAL_VERTEX_ATTRIB10_NV
GL_EVAL_VERTEX_ATTRIB11_NV = GL_EVAL_VERTEX_ATTRIB11_NV
GL_EVAL_VERTEX_ATTRIB12_NV = GL_EVAL_VERTEX_ATTRIB12_NV
GL_EVAL_VERTEX_ATTRIB13_NV = GL_EVAL_VERTEX_ATTRIB13_NV
GL_EVAL_VERTEX_ATTRIB14_NV = GL_EVAL_VERTEX_ATTRIB14_NV
GL_EVAL_VERTEX_ATTRIB15_NV = GL_EVAL_VERTEX_ATTRIB15_NV
GL_EVAL_VERTEX_ATTRIB1_NV = GL_EVAL_VERTEX_ATTRIB1_NV
GL_EVAL_VERTEX_ATTRIB2_NV = GL_EVAL_VERTEX_ATTRIB2_NV
GL_EVAL_VERTEX_ATTRIB3_NV = GL_EVAL_VERTEX_ATTRIB3_NV
GL_EVAL_VERTEX_ATTRIB4_NV = GL_EVAL_VERTEX_ATTRIB4_NV
GL_EVAL_VERTEX_ATTRIB5_NV = GL_EVAL_VERTEX_ATTRIB5_NV
GL_EVAL_VERTEX_ATTRIB6_NV = GL_EVAL_VERTEX_ATTRIB6_NV
GL_EVAL_VERTEX_ATTRIB7_NV = GL_EVAL_VERTEX_ATTRIB7_NV
GL_EVAL_VERTEX_ATTRIB8_NV = GL_EVAL_VERTEX_ATTRIB8_NV
GL_EVAL_VERTEX_ATTRIB9_NV = GL_EVAL_VERTEX_ATTRIB9_NV
GL_EXP = GL_EXP
GL_EXP2 = GL_EXP2
GL_EXPAND_NEGATE_NV = GL_EXPAND_NEGATE_NV
GL_EXPAND_NORMAL_NV = GL_EXPAND_NORMAL_NV
GL_EXTENSIONS = GL_EXTENSIONS
GL_EYE_DISTANCE_TO_LINE_SGIS = GL_EYE_DISTANCE_TO_LINE_SGIS
GL_EYE_DISTANCE_TO_POINT_SGIS = GL_EYE_DISTANCE_TO_POINT_SGIS
GL_EYE_LINEAR = GL_EYE_LINEAR
GL_EYE_LINE_SGIS = GL_EYE_LINE_SGIS
GL_EYE_PLANE = GL_EYE_PLANE
GL_EYE_PLANE_ABSOLUTE_NV = GL_EYE_PLANE_ABSOLUTE_NV
GL_EYE_POINT_SGIS = GL_EYE_POINT_SGIS
GL_EYE_RADIAL_NV = GL_EYE_RADIAL_NV
GL_E_TIMES_F_NV = GL_E_TIMES_F_NV
GL_FALSE = GL_FALSE
GL_FASTEST = GL_FASTEST
GL_FEEDBACK = GL_FEEDBACK
GL_FEEDBACK_BUFFER_POINTER = GL_FEEDBACK_BUFFER_POINTER
GL_FEEDBACK_BUFFER_SIZE = GL_FEEDBACK_BUFFER_SIZE
GL_FEEDBACK_BUFFER_TYPE = GL_FEEDBACK_BUFFER_TYPE
GL_FENCE_APPLE = GL_FENCE_APPLE
GL_FENCE_CONDITION_NV = GL_FENCE_CONDITION_NV
GL_FENCE_STATUS_NV = GL_FENCE_STATUS_NV
GL_FILL = GL_FILL
GL_FILTER4_SGIS = GL_FILTER4_SGIS
GL_FIXED_ONLY_ARB = GL_FIXED_ONLY_ARB
GL_FLAT = GL_FLAT
GL_FLOAT = GL_FLOAT
GL_FLOAT_CLEAR_COLOR_VALUE_NV = GL_FLOAT_CLEAR_COLOR_VALUE_NV
GL_FLOAT_MAT2 = GL_FLOAT_MAT2
GL_FLOAT_MAT2_ARB = GL_FLOAT_MAT2_ARB
GL_FLOAT_MAT2x3 = GL_FLOAT_MAT2x3
GL_FLOAT_MAT2x4 = GL_FLOAT_MAT2x4
GL_FLOAT_MAT3 = GL_FLOAT_MAT3
GL_FLOAT_MAT3_ARB = GL_FLOAT_MAT3_ARB
GL_FLOAT_MAT3x2 = GL_FLOAT_MAT3x2
GL_FLOAT_MAT3x4 = GL_FLOAT_MAT3x4
GL_FLOAT_MAT4 = GL_FLOAT_MAT4
GL_FLOAT_MAT4_ARB = GL_FLOAT_MAT4_ARB
GL_FLOAT_MAT4x2 = GL_FLOAT_MAT4x2
GL_FLOAT_MAT4x3 = GL_FLOAT_MAT4x3
GL_FLOAT_R16_NV = GL_FLOAT_R16_NV
GL_FLOAT_R32_NV = GL_FLOAT_R32_NV
GL_FLOAT_RG16_NV = GL_FLOAT_RG16_NV
GL_FLOAT_RG32_NV = GL_FLOAT_RG32_NV
GL_FLOAT_RGB16_NV = GL_FLOAT_RGB16_NV
GL_FLOAT_RGB32_NV = GL_FLOAT_RGB32_NV
GL_FLOAT_RGBA16_NV = GL_FLOAT_RGBA16_NV
GL_FLOAT_RGBA32_NV = GL_FLOAT_RGBA32_NV
GL_FLOAT_RGBA_MODE_NV = GL_FLOAT_RGBA_MODE_NV
GL_FLOAT_RGBA_NV = GL_FLOAT_RGBA_NV
GL_FLOAT_RGB_NV = GL_FLOAT_RGB_NV
GL_FLOAT_RG_NV = GL_FLOAT_RG_NV
GL_FLOAT_R_NV = GL_FLOAT_R_NV
GL_FLOAT_VEC2 = GL_FLOAT_VEC2
GL_FLOAT_VEC2_ARB = GL_FLOAT_VEC2_ARB
GL_FLOAT_VEC3 = GL_FLOAT_VEC3
GL_FLOAT_VEC3_ARB = GL_FLOAT_VEC3_ARB
GL_FLOAT_VEC4 = GL_FLOAT_VEC4
GL_FLOAT_VEC4_ARB = GL_FLOAT_VEC4_ARB
GL_FOG = GL_FOG
GL_FOG_BIT = GL_FOG_BIT
GL_FOG_COLOR = GL_FOG_COLOR
GL_FOG_COORD = GL_FOG_COORDINATE
GL_FOG_COORDINATE = GL_FOG_COORDINATE
GL_FOG_COORDINATE_ARRAY = GL_FOG_COORDINATE_ARRAY
GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING = GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING
GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB = GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB
GL_FOG_COORDINATE_ARRAY_EXT = GL_FOG_COORDINATE_ARRAY_EXT
GL_FOG_COORDINATE_ARRAY_LIST_IBM = GL_FOG_COORDINATE_ARRAY_LIST_IBM
GL_FOG_COORDINATE_ARRAY_LIST_STRIDE_IBM = GL_FOG_COORDINATE_ARRAY_LIST_STRIDE_IBM
GL_FOG_COORDINATE_ARRAY_POINTER = GL_FOG_COORDINATE_ARRAY_POINTER
GL_FOG_COORDINATE_ARRAY_POINTER_EXT = GL_FOG_COORDINATE_ARRAY_POINTER_EXT
GL_FOG_COORDINATE_ARRAY_STRIDE = GL_FOG_COORDINATE_ARRAY_STRIDE
GL_FOG_COORDINATE_ARRAY_STRIDE_EXT = GL_FOG_COORDINATE_ARRAY_STRIDE_EXT
GL_FOG_COORDINATE_ARRAY_TYPE = GL_FOG_COORDINATE_ARRAY_TYPE
GL_FOG_COORDINATE_ARRAY_TYPE_EXT = GL_FOG_COORDINATE_ARRAY_TYPE_EXT
GL_FOG_COORDINATE_EXT = GL_FOG_COORDINATE_EXT
GL_FOG_COORDINATE_SOURCE = GL_FOG_COORDINATE_SOURCE
GL_FOG_COORDINATE_SOURCE_EXT = GL_FOG_COORDINATE_SOURCE_EXT
GL_FOG_COORD_ARRAY = GL_FOG_COORDINATE_ARRAY
GL_FOG_COORD_ARRAY_BUFFER_BINDING = GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING
GL_FOG_COORD_ARRAY_POINTER = GL_FOG_COORDINATE_ARRAY_POINTER
GL_FOG_COORD_ARRAY_STRIDE = GL_FOG_COORDINATE_ARRAY_STRIDE
GL_FOG_COORD_ARRAY_TYPE = GL_FOG_COORDINATE_ARRAY_TYPE
GL_FOG_COORD_SRC = GL_FOG_COORDINATE_SOURCE
GL_FOG_DENSITY = GL_FOG_DENSITY
GL_FOG_DISTANCE_MODE_NV = GL_FOG_DISTANCE_MODE_NV
GL_FOG_END = GL_FOG_END
GL_FOG_FUNC_POINTS_SGIS = GL_FOG_FUNC_POINTS_SGIS
GL_FOG_FUNC_SGIS = GL_FOG_FUNC_SGIS
GL_FOG_HINT = GL_FOG_HINT
GL_FOG_INDEX = GL_FOG_INDEX
GL_FOG_MODE = GL_FOG_MODE
GL_FOG_OFFSET_SGIX = GL_FOG_OFFSET_SGIX
GL_FOG_OFFSET_VALUE_SGIX = GL_FOG_OFFSET_VALUE_SGIX
GL_FOG_SCALE_SGIX = GL_FOG_SCALE_SGIX
GL_FOG_SCALE_VALUE_SGIX = GL_FOG_SCALE_VALUE_SGIX
GL_FOG_SPECULAR_TEXTURE_WIN = GL_FOG_SPECULAR_TEXTURE_WIN
GL_FOG_START = GL_FOG_START
GL_FORCE_BLUE_TO_ONE_NV = GL_FORCE_BLUE_TO_ONE_NV
GL_FORMAT_SUBSAMPLE_244_244_OML = GL_FORMAT_SUBSAMPLE_244_244_OML
GL_FORMAT_SUBSAMPLE_24_24_OML = GL_FORMAT_SUBSAMPLE_24_24_OML
GL_FRAGMENT_COLOR_EXT = GL_FRAGMENT_COLOR_EXT
GL_FRAGMENT_COLOR_MATERIAL_FACE_SGIX = GL_FRAGMENT_COLOR_MATERIAL_FACE_SGIX
GL_FRAGMENT_COLOR_MATERIAL_PARAMETER_SGIX = GL_FRAGMENT_COLOR_MATERIAL_PARAMETER_SGIX
GL_FRAGMENT_COLOR_MATERIAL_SGIX = GL_FRAGMENT_COLOR_MATERIAL_SGIX
GL_FRAGMENT_DEPTH = GL_FRAGMENT_DEPTH
GL_FRAGMENT_DEPTH_EXT = GL_FRAGMENT_DEPTH_EXT
GL_FRAGMENT_LIGHT0_SGIX = GL_FRAGMENT_LIGHT0_SGIX
GL_FRAGMENT_LIGHT1_SGIX = GL_FRAGMENT_LIGHT1_SGIX
GL_FRAGMENT_LIGHT2_SGIX = GL_FRAGMENT_LIGHT2_SGIX
GL_FRAGMENT_LIGHT3_SGIX = GL_FRAGMENT_LIGHT3_SGIX
GL_FRAGMENT_LIGHT4_SGIX = GL_FRAGMENT_LIGHT4_SGIX
GL_FRAGMENT_LIGHT5_SGIX = GL_FRAGMENT_LIGHT5_SGIX
GL_FRAGMENT_LIGHT6_SGIX = GL_FRAGMENT_LIGHT6_SGIX
GL_FRAGMENT_LIGHT7_SGIX = GL_FRAGMENT_LIGHT7_SGIX
GL_FRAGMENT_LIGHTING_SGIX = GL_FRAGMENT_LIGHTING_SGIX
GL_FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX = GL_FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX
GL_FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX = GL_FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX
GL_FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX = GL_FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX
GL_FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX = GL_FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX
GL_FRAGMENT_MATERIAL_EXT = GL_FRAGMENT_MATERIAL_EXT
GL_FRAGMENT_NORMAL_EXT = GL_FRAGMENT_NORMAL_EXT
GL_FRAGMENT_PROGRAM_ARB = GL_FRAGMENT_PROGRAM_ARB
GL_FRAGMENT_PROGRAM_BINDING_NV = GL_FRAGMENT_PROGRAM_BINDING_NV
GL_FRAGMENT_PROGRAM_NV = GL_FRAGMENT_PROGRAM_NV
GL_FRAGMENT_SHADER = GL_FRAGMENT_SHADER
GL_FRAGMENT_SHADER_ARB = GL_FRAGMENT_SHADER_ARB
GL_FRAGMENT_SHADER_ATI = GL_FRAGMENT_SHADER_ATI
GL_FRAGMENT_SHADER_DERIVATIVE_HINT = GL_FRAGMENT_SHADER_DERIVATIVE_HINT
GL_FRAGMENT_SHADER_DERIVATIVE_HINT_ARB = GL_FRAGMENT_SHADER_DERIVATIVE_HINT_ARB
GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT = GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT
GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT = GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT
GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT = GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT
GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT = GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT
GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT = GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT
GL_FRAMEBUFFER_BINDING_EXT = GL_FRAMEBUFFER_BINDING_EXT
GL_FRAMEBUFFER_COMPLETE_EXT = GL_FRAMEBUFFER_COMPLETE_EXT
GL_FRAMEBUFFER_EXT = GL_FRAMEBUFFER_EXT
GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT = GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT
GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT = GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT
GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT = GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT
GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT = GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT
GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT = GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT
GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT = GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT
GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT = GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT
GL_FRAMEBUFFER_UNSUPPORTED_EXT = GL_FRAMEBUFFER_UNSUPPORTED_EXT
GL_FRAMEZOOM_FACTOR_SGIX = GL_FRAMEZOOM_FACTOR_SGIX
GL_FRAMEZOOM_SGIX = GL_FRAMEZOOM_SGIX
GL_FRONT = GL_FRONT
GL_FRONT_AND_BACK = GL_FRONT_AND_BACK
GL_FRONT_FACE = GL_FRONT_FACE
GL_FRONT_LEFT = GL_FRONT_LEFT
GL_FRONT_RIGHT = GL_FRONT_RIGHT
GL_FULL_RANGE_EXT = GL_FULL_RANGE_EXT
GL_FULL_STIPPLE_HINT_PGI = GL_FULL_STIPPLE_HINT_PGI
GL_FUNC_ADD = GL_FUNC_ADD
GL_FUNC_ADD_EXT = GL_FUNC_ADD_EXT
GL_FUNC_REVERSE_SUBTRACT = GL_FUNC_REVERSE_SUBTRACT
GL_FUNC_REVERSE_SUBTRACT_EXT = GL_FUNC_REVERSE_SUBTRACT_EXT
GL_FUNC_SUBTRACT = GL_FUNC_SUBTRACT
GL_FUNC_SUBTRACT_EXT = GL_FUNC_SUBTRACT_EXT
GL_GENERATE_MIPMAP = GL_GENERATE_MIPMAP
GL_GENERATE_MIPMAP_HINT = GL_GENERATE_MIPMAP_HINT
GL_GENERATE_MIPMAP_HINT_SGIS = GL_GENERATE_MIPMAP_HINT_SGIS
GL_GENERATE_MIPMAP_SGIS = GL_GENERATE_MIPMAP_SGIS
GL_GEOMETRY_DEFORMATION_BIT_SGIX = GL_GEOMETRY_DEFORMATION_BIT_SGIX
GL_GEOMETRY_DEFORMATION_SGIX = GL_GEOMETRY_DEFORMATION_SGIX
GL_GEQUAL = GL_GEQUAL
GL_GET_CP_SIZES = {GL_CONVOLUTION_BORDER_MODE: 1, GL_CONVOLUTION_FILTER_SCALE: 4, GL_CONVOLUTION_FILTER_BIAS: 4, GL_CONVOLUTION_FORMAT: 1, GL_CONVOLUTION_WIDTH: 1, GL_CONVOLUTION_HEIGHT: 1, GL_MAX_CONVOLUTION_WIDTH: 1, GL_MAX_CONVOLUTION_HEIGHT: 1, GL_CONVOLUTION_BORDER_COLOR: 4}
GL_GET_CTP_SIZES = {GL_COLOR_TABLE_FORMAT: 1, GL_COLOR_TABLE_WIDTH: 1, GL_COLOR_TABLE_RED_SIZE: 1, GL_COLOR_TABLE_GREEN_SIZE: 1, GL_COLOR_TABLE_BLUE_SIZE: 1, GL_COLOR_TABLE_ALPHA_SIZE: 1, GL_COLOR_TABLE_LUMINANCE_SIZE: 1, GL_COLOR_TABLE_INTENSITY_SIZE: 1}
GL_GLEXT_VERSION = GL_GLEXT_VERSION
GL_GLOBAL_ALPHA_FACTOR_SUN = GL_GLOBAL_ALPHA_FACTOR_SUN
GL_GLOBAL_ALPHA_SUN = GL_GLOBAL_ALPHA_SUN
GL_GREATER = GL_GREATER
GL_GREEN = GL_GREEN
GL_GREEN_BIAS = GL_GREEN_BIAS
GL_GREEN_BITS = GL_GREEN_BITS
GL_GREEN_BIT_ATI = GL_GREEN_BIT_ATI
GL_GREEN_MAX_CLAMP_INGR = GL_GREEN_MAX_CLAMP_INGR
GL_GREEN_MIN_CLAMP_INGR = GL_GREEN_MIN_CLAMP_INGR
GL_GREEN_SCALE = GL_GREEN_SCALE
GL_HALF_BIAS_NEGATE_NV = GL_HALF_BIAS_NEGATE_NV
GL_HALF_BIAS_NORMAL_NV = GL_HALF_BIAS_NORMAL_NV
GL_HALF_BIT_ATI = GL_HALF_BIT_ATI
GL_HALF_FLOAT_ARB = GL_HALF_FLOAT_ARB
GL_HALF_FLOAT_NV = GL_HALF_FLOAT_NV
GL_HILO16_NV = GL_HILO16_NV
GL_HILO8_NV = GL_HILO8_NV
GL_HILO_NV = GL_HILO_NV
GL_HINT_BIT = GL_HINT_BIT
GL_HISTOGRAM = GL_HISTOGRAM
GL_HISTOGRAM_ALPHA_SIZE = GL_HISTOGRAM_ALPHA_SIZE
GL_HISTOGRAM_ALPHA_SIZE_EXT = GL_HISTOGRAM_ALPHA_SIZE_EXT
GL_HISTOGRAM_BLUE_SIZE = GL_HISTOGRAM_BLUE_SIZE
GL_HISTOGRAM_BLUE_SIZE_EXT = GL_HISTOGRAM_BLUE_SIZE_EXT
GL_HISTOGRAM_EXT = GL_HISTOGRAM_EXT
GL_HISTOGRAM_FORMAT = GL_HISTOGRAM_FORMAT
GL_HISTOGRAM_FORMAT_EXT = GL_HISTOGRAM_FORMAT_EXT
GL_HISTOGRAM_GREEN_SIZE = GL_HISTOGRAM_GREEN_SIZE
GL_HISTOGRAM_GREEN_SIZE_EXT = GL_HISTOGRAM_GREEN_SIZE_EXT
GL_HISTOGRAM_LUMINANCE_SIZE = GL_HISTOGRAM_LUMINANCE_SIZE
GL_HISTOGRAM_LUMINANCE_SIZE_EXT = GL_HISTOGRAM_LUMINANCE_SIZE_EXT
GL_HISTOGRAM_RED_SIZE = GL_HISTOGRAM_RED_SIZE
GL_HISTOGRAM_RED_SIZE_EXT = GL_HISTOGRAM_RED_SIZE_EXT
GL_HISTOGRAM_SINK = GL_HISTOGRAM_SINK
GL_HISTOGRAM_SINK_EXT = GL_HISTOGRAM_SINK_EXT
GL_HISTOGRAM_WIDTH = GL_HISTOGRAM_WIDTH
GL_HISTOGRAM_WIDTH_EXT = GL_HISTOGRAM_WIDTH_EXT
GL_HI_BIAS_NV = GL_HI_BIAS_NV
GL_HI_SCALE_NV = GL_HI_SCALE_NV
GL_IDENTITY_NV = GL_IDENTITY_NV
GL_IGNORE_BORDER_HP = GL_IGNORE_BORDER_HP
GL_IMAGE_CUBIC_WEIGHT_HP = GL_IMAGE_CUBIC_WEIGHT_HP
GL_IMAGE_MAG_FILTER_HP = GL_IMAGE_MAG_FILTER_HP
GL_IMAGE_MIN_FILTER_HP = GL_IMAGE_MIN_FILTER_HP
GL_IMAGE_ROTATE_ANGLE_HP = GL_IMAGE_ROTATE_ANGLE_HP
GL_IMAGE_ROTATE_ORIGIN_X_HP = GL_IMAGE_ROTATE_ORIGIN_X_HP
GL_IMAGE_ROTATE_ORIGIN_Y_HP = GL_IMAGE_ROTATE_ORIGIN_Y_HP
GL_IMAGE_SCALE_X_HP = GL_IMAGE_SCALE_X_HP
GL_IMAGE_SCALE_Y_HP = GL_IMAGE_SCALE_Y_HP
GL_IMAGE_TRANSFORM_2D_HP = GL_IMAGE_TRANSFORM_2D_HP
GL_IMAGE_TRANSLATE_X_HP = GL_IMAGE_TRANSLATE_X_HP
GL_IMAGE_TRANSLATE_Y_HP = GL_IMAGE_TRANSLATE_Y_HP
GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES = GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES
GL_IMPLEMENTATION_COLOR_READ_TYPE_OES = GL_IMPLEMENTATION_COLOR_READ_TYPE_OES
GL_INCR = GL_INCR
GL_INCR_WRAP = GL_INCR_WRAP
GL_INCR_WRAP_EXT = GL_INCR_WRAP_EXT
GL_INDEX_ARRAY = GL_INDEX_ARRAY
GL_INDEX_ARRAY_BUFFER_BINDING = GL_INDEX_ARRAY_BUFFER_BINDING
GL_INDEX_ARRAY_BUFFER_BINDING_ARB = GL_INDEX_ARRAY_BUFFER_BINDING_ARB
GL_INDEX_ARRAY_COUNT_EXT = GL_INDEX_ARRAY_COUNT_EXT
GL_INDEX_ARRAY_EXT = GL_INDEX_ARRAY_EXT
GL_INDEX_ARRAY_LIST_IBM = GL_INDEX_ARRAY_LIST_IBM
GL_INDEX_ARRAY_LIST_STRIDE_IBM = GL_INDEX_ARRAY_LIST_STRIDE_IBM
GL_INDEX_ARRAY_POINTER = GL_INDEX_ARRAY_POINTER
GL_INDEX_ARRAY_POINTER_EXT = GL_INDEX_ARRAY_POINTER_EXT
GL_INDEX_ARRAY_STRIDE = GL_INDEX_ARRAY_STRIDE
GL_INDEX_ARRAY_STRIDE_EXT = GL_INDEX_ARRAY_STRIDE_EXT
GL_INDEX_ARRAY_TYPE = GL_INDEX_ARRAY_TYPE
GL_INDEX_ARRAY_TYPE_EXT = GL_INDEX_ARRAY_TYPE_EXT
GL_INDEX_BITS = GL_INDEX_BITS
GL_INDEX_BIT_PGI = GL_INDEX_BIT_PGI
GL_INDEX_CLEAR_VALUE = GL_INDEX_CLEAR_VALUE
GL_INDEX_LOGIC_OP = GL_INDEX_LOGIC_OP
GL_INDEX_MATERIAL_EXT = GL_INDEX_MATERIAL_EXT
GL_INDEX_MATERIAL_FACE_EXT = GL_INDEX_MATERIAL_FACE_EXT
GL_INDEX_MATERIAL_PARAMETER_EXT = GL_INDEX_MATERIAL_PARAMETER_EXT
GL_INDEX_MODE = GL_INDEX_MODE
GL_INDEX_OFFSET = GL_INDEX_OFFSET
GL_INDEX_SHIFT = GL_INDEX_SHIFT
GL_INDEX_TEST_EXT = GL_INDEX_TEST_EXT
GL_INDEX_TEST_FUNC_EXT = GL_INDEX_TEST_FUNC_EXT
GL_INDEX_TEST_REF_EXT = GL_INDEX_TEST_REF_EXT
GL_INDEX_WRITEMASK = GL_INDEX_WRITEMASK
GL_INFO_LOG_LENGTH = GL_INFO_LOG_LENGTH
GL_INSTRUMENT_BUFFER_POINTER_SGIX = GL_INSTRUMENT_BUFFER_POINTER_SGIX
GL_INSTRUMENT_MEASUREMENTS_SGIX = GL_INSTRUMENT_MEASUREMENTS_SGIX
GL_INT = GL_INT
GL_INTENSITY = GL_INTENSITY
GL_INTENSITY12 = GL_INTENSITY12
GL_INTENSITY12_EXT = GL_INTENSITY12_EXT
GL_INTENSITY16 = GL_INTENSITY16
GL_INTENSITY16F_ARB = GL_INTENSITY16F_ARB
GL_INTENSITY16_EXT = GL_INTENSITY16_EXT
GL_INTENSITY32F_ARB = GL_INTENSITY32F_ARB
GL_INTENSITY4 = GL_INTENSITY4
GL_INTENSITY4_EXT = GL_INTENSITY4_EXT
GL_INTENSITY8 = GL_INTENSITY8
GL_INTENSITY8_EXT = GL_INTENSITY8_EXT
GL_INTENSITY_EXT = GL_INTENSITY_EXT
GL_INTENSITY_FLOAT16_ATI = GL_INTENSITY_FLOAT16_ATI
GL_INTENSITY_FLOAT32_ATI = GL_INTENSITY_FLOAT32_ATI
GL_INTERLACE_OML = GL_INTERLACE_OML
GL_INTERLACE_READ_INGR = GL_INTERLACE_READ_INGR
GL_INTERLACE_READ_OML = GL_INTERLACE_READ_OML
GL_INTERLACE_SGIX = GL_INTERLACE_SGIX
GL_INTERLEAVED_ARRAY_POINTER = GL_INTERLEAVED_ARRAY_POINTER
GL_INTERPOLATE = GL_INTERPOLATE
GL_INTERPOLATE_ARB = GL_INTERPOLATE_ARB
GL_INTERPOLATE_EXT = GL_INTERPOLATE_EXT
GL_INT_VEC2 = GL_INT_VEC2
GL_INT_VEC2_ARB = GL_INT_VEC2_ARB
GL_INT_VEC3 = GL_INT_VEC3
GL_INT_VEC3_ARB = GL_INT_VEC3_ARB
GL_INT_VEC4 = GL_INT_VEC4
GL_INT_VEC4_ARB = GL_INT_VEC4_ARB
GL_INVALID_ENUM = GL_INVALID_ENUM
GL_INVALID_FRAMEBUFFER_OPERATION_EXT = GL_INVALID_FRAMEBUFFER_OPERATION_EXT
GL_INVALID_OPERATION = GL_INVALID_OPERATION
GL_INVALID_VALUE = GL_INVALID_VALUE
GL_INVARIANT_DATATYPE_EXT = GL_INVARIANT_DATATYPE_EXT
GL_INVARIANT_EXT = GL_INVARIANT_EXT
GL_INVARIANT_VALUE_EXT = GL_INVARIANT_VALUE_EXT
GL_INVERSE_NV = GL_INVERSE_NV
GL_INVERSE_TRANSPOSE_NV = GL_INVERSE_TRANSPOSE_NV
GL_INVERT = GL_INVERT
GL_INVERTED_SCREEN_W_REND = GL_INVERTED_SCREEN_W_REND
GL_IR_INSTRUMENT1_SGIX = GL_IR_INSTRUMENT1_SGIX
GL_IUI_N3F_V2F_EXT = GL_IUI_N3F_V2F_EXT
GL_IUI_N3F_V3F_EXT = GL_IUI_N3F_V3F_EXT
GL_IUI_V2F_EXT = GL_IUI_V2F_EXT
GL_IUI_V3F_EXT = GL_IUI_V3F_EXT
GL_KEEP = GL_KEEP
GL_LEFT = GL_LEFT
GL_LEQUAL = GL_LEQUAL
GL_LERP_ATI = GL_LERP_ATI
GL_LESS = GL_LESS
GL_LIGHT0 = GL_LIGHT0
GL_LIGHT1 = GL_LIGHT1
GL_LIGHT2 = GL_LIGHT2
GL_LIGHT3 = GL_LIGHT3
GL_LIGHT4 = GL_LIGHT4
GL_LIGHT5 = GL_LIGHT5
GL_LIGHT6 = GL_LIGHT6
GL_LIGHT7 = GL_LIGHT7
GL_LIGHTING = GL_LIGHTING
GL_LIGHTING_BIT = GL_LIGHTING_BIT
GL_LIGHT_ENV_MODE_SGIX = GL_LIGHT_ENV_MODE_SGIX
GL_LIGHT_MODEL_AMBIENT = GL_LIGHT_MODEL_AMBIENT
GL_LIGHT_MODEL_COLOR_CONTROL = GL_LIGHT_MODEL_COLOR_CONTROL
GL_LIGHT_MODEL_COLOR_CONTROL_EXT = GL_LIGHT_MODEL_COLOR_CONTROL_EXT
GL_LIGHT_MODEL_LOCAL_VIEWER = GL_LIGHT_MODEL_LOCAL_VIEWER
GL_LIGHT_MODEL_SPECULAR_VECTOR_APPLE = GL_LIGHT_MODEL_SPECULAR_VECTOR_APPLE
GL_LIGHT_MODEL_TWO_SIDE = GL_LIGHT_MODEL_TWO_SIDE
GL_LINE = GL_LINE
GL_LINEAR = GL_LINEAR
GL_LINEAR_ATTENUATION = GL_LINEAR_ATTENUATION
GL_LINEAR_CLIPMAP_LINEAR_SGIX = GL_LINEAR_CLIPMAP_LINEAR_SGIX
GL_LINEAR_CLIPMAP_NEAREST_SGIX = GL_LINEAR_CLIPMAP_NEAREST_SGIX
GL_LINEAR_DETAIL_ALPHA_SGIS = GL_LINEAR_DETAIL_ALPHA_SGIS
GL_LINEAR_DETAIL_COLOR_SGIS = GL_LINEAR_DETAIL_COLOR_SGIS
GL_LINEAR_DETAIL_SGIS = GL_LINEAR_DETAIL_SGIS
GL_LINEAR_MIPMAP_LINEAR = GL_LINEAR_MIPMAP_LINEAR
GL_LINEAR_MIPMAP_NEAREST = GL_LINEAR_MIPMAP_NEAREST
GL_LINEAR_SHARPEN_ALPHA_SGIS = GL_LINEAR_SHARPEN_ALPHA_SGIS
GL_LINEAR_SHARPEN_COLOR_SGIS = GL_LINEAR_SHARPEN_COLOR_SGIS
GL_LINEAR_SHARPEN_SGIS = GL_LINEAR_SHARPEN_SGIS
GL_LINES = GL_LINES
GL_LINE_BIT = GL_LINE_BIT
GL_LINE_LOOP = GL_LINE_LOOP
GL_LINE_RESET_TOKEN = GL_LINE_RESET_TOKEN
GL_LINE_SMOOTH = GL_LINE_SMOOTH
GL_LINE_SMOOTH_HINT = GL_LINE_SMOOTH_HINT
GL_LINE_STIPPLE = GL_LINE_STIPPLE
GL_LINE_STIPPLE_PATTERN = GL_LINE_STIPPLE_PATTERN
GL_LINE_STIPPLE_REPEAT = GL_LINE_STIPPLE_REPEAT
GL_LINE_STRIP = GL_LINE_STRIP
GL_LINE_TOKEN = GL_LINE_TOKEN
GL_LINE_WIDTH = GL_LINE_WIDTH
GL_LINE_WIDTH_GRANULARITY = GL_SMOOTH_LINE_WIDTH_GRANULARITY
GL_LINE_WIDTH_RANGE = GL_SMOOTH_LINE_WIDTH_RANGE
GL_LINK_STATUS = GL_LINK_STATUS
GL_LIST_BASE = GL_LIST_BASE
GL_LIST_BIT = GL_LIST_BIT
GL_LIST_INDEX = GL_LIST_INDEX
GL_LIST_MODE = GL_LIST_MODE
GL_LIST_PRIORITY_SGIX = GL_LIST_PRIORITY_SGIX
GL_LOAD = GL_LOAD
GL_LOCAL_CONSTANT_DATATYPE_EXT = GL_LOCAL_CONSTANT_DATATYPE_EXT
GL_LOCAL_CONSTANT_EXT = GL_LOCAL_CONSTANT_EXT
GL_LOCAL_CONSTANT_VALUE_EXT = GL_LOCAL_CONSTANT_VALUE_EXT
GL_LOCAL_EXT = GL_LOCAL_EXT
GL_LOGIC_OP = GL_INDEX_LOGIC_OP
GL_LOGIC_OP_MODE = GL_LOGIC_OP_MODE
GL_LOWER_LEFT = GL_LOWER_LEFT
GL_LO_BIAS_NV = GL_LO_BIAS_NV
GL_LO_SCALE_NV = GL_LO_SCALE_NV
GL_LUMINANCE = GL_LUMINANCE
GL_LUMINANCE12 = GL_LUMINANCE12
GL_LUMINANCE12_ALPHA12 = GL_LUMINANCE12_ALPHA12
GL_LUMINANCE12_ALPHA12_EXT = GL_LUMINANCE12_ALPHA12_EXT
GL_LUMINANCE12_ALPHA4 = GL_LUMINANCE12_ALPHA4
GL_LUMINANCE12_ALPHA4_EXT = GL_LUMINANCE12_ALPHA4_EXT
GL_LUMINANCE12_EXT = GL_LUMINANCE12_EXT
GL_LUMINANCE16 = GL_LUMINANCE16
GL_LUMINANCE16F_ARB = GL_LUMINANCE16F_ARB
GL_LUMINANCE16_ALPHA16 = GL_LUMINANCE16_ALPHA16
GL_LUMINANCE16_ALPHA16_EXT = GL_LUMINANCE16_ALPHA16_EXT
GL_LUMINANCE16_EXT = GL_LUMINANCE16_EXT
GL_LUMINANCE32F_ARB = GL_LUMINANCE32F_ARB
GL_LUMINANCE4 = GL_LUMINANCE4
GL_LUMINANCE4_ALPHA4 = GL_LUMINANCE4_ALPHA4
GL_LUMINANCE4_ALPHA4_EXT = GL_LUMINANCE4_ALPHA4_EXT
GL_LUMINANCE4_EXT = GL_LUMINANCE4_EXT
GL_LUMINANCE6_ALPHA2 = GL_LUMINANCE6_ALPHA2
GL_LUMINANCE6_ALPHA2_EXT = GL_LUMINANCE6_ALPHA2_EXT
GL_LUMINANCE8 = GL_LUMINANCE8
GL_LUMINANCE8_ALPHA8 = GL_LUMINANCE8_ALPHA8
GL_LUMINANCE8_ALPHA8_EXT = GL_LUMINANCE8_ALPHA8_EXT
GL_LUMINANCE8_EXT = GL_LUMINANCE8_EXT
GL_LUMINANCE_ALPHA = GL_LUMINANCE_ALPHA
GL_LUMINANCE_ALPHA16F_ARB = GL_LUMINANCE_ALPHA16F_ARB
GL_LUMINANCE_ALPHA32F_ARB = GL_LUMINANCE_ALPHA32F_ARB
GL_LUMINANCE_ALPHA_FLOAT16_ATI = GL_LUMINANCE_ALPHA_FLOAT16_ATI
GL_LUMINANCE_ALPHA_FLOAT32_ATI = GL_LUMINANCE_ALPHA_FLOAT32_ATI
GL_LUMINANCE_FLOAT16_ATI = GL_LUMINANCE_FLOAT16_ATI
GL_LUMINANCE_FLOAT32_ATI = GL_LUMINANCE_FLOAT32_ATI
GL_MAD_ATI = GL_MAD_ATI
GL_MAGNITUDE_BIAS_NV = GL_MAGNITUDE_BIAS_NV
GL_MAGNITUDE_SCALE_NV = GL_MAGNITUDE_SCALE_NV
GL_MAP1_BINORMAL_EXT = GL_MAP1_BINORMAL_EXT
GL_MAP1_COLOR_4 = GL_MAP1_COLOR_4
GL_MAP1_GRID_DOMAIN = GL_MAP1_GRID_DOMAIN
GL_MAP1_GRID_SEGMENTS = GL_MAP1_GRID_SEGMENTS
GL_MAP1_INDEX = GL_MAP1_INDEX
GL_MAP1_NORMAL = GL_MAP1_NORMAL
GL_MAP1_TANGENT_EXT = GL_MAP1_TANGENT_EXT
GL_MAP1_TEXTURE_COORD_1 = GL_MAP1_TEXTURE_COORD_1
GL_MAP1_TEXTURE_COORD_2 = GL_MAP1_TEXTURE_COORD_2
GL_MAP1_TEXTURE_COORD_3 = GL_MAP1_TEXTURE_COORD_3
GL_MAP1_TEXTURE_COORD_4 = GL_MAP1_TEXTURE_COORD_4
GL_MAP1_VERTEX_3 = GL_MAP1_VERTEX_3
GL_MAP1_VERTEX_4 = GL_MAP1_VERTEX_4
GL_MAP1_VERTEX_ATTRIB0_4_NV = GL_MAP1_VERTEX_ATTRIB0_4_NV
GL_MAP1_VERTEX_ATTRIB10_4_NV = GL_MAP1_VERTEX_ATTRIB10_4_NV
GL_MAP1_VERTEX_ATTRIB11_4_NV = GL_MAP1_VERTEX_ATTRIB11_4_NV
GL_MAP1_VERTEX_ATTRIB12_4_NV = GL_MAP1_VERTEX_ATTRIB12_4_NV
GL_MAP1_VERTEX_ATTRIB13_4_NV = GL_MAP1_VERTEX_ATTRIB13_4_NV
GL_MAP1_VERTEX_ATTRIB14_4_NV = GL_MAP1_VERTEX_ATTRIB14_4_NV
GL_MAP1_VERTEX_ATTRIB15_4_NV = GL_MAP1_VERTEX_ATTRIB15_4_NV
GL_MAP1_VERTEX_ATTRIB1_4_NV = GL_MAP1_VERTEX_ATTRIB1_4_NV
GL_MAP1_VERTEX_ATTRIB2_4_NV = GL_MAP1_VERTEX_ATTRIB2_4_NV
GL_MAP1_VERTEX_ATTRIB3_4_NV = GL_MAP1_VERTEX_ATTRIB3_4_NV
GL_MAP1_VERTEX_ATTRIB4_4_NV = GL_MAP1_VERTEX_ATTRIB4_4_NV
GL_MAP1_VERTEX_ATTRIB5_4_NV = GL_MAP1_VERTEX_ATTRIB5_4_NV
GL_MAP1_VERTEX_ATTRIB6_4_NV = GL_MAP1_VERTEX_ATTRIB6_4_NV
GL_MAP1_VERTEX_ATTRIB7_4_NV = GL_MAP1_VERTEX_ATTRIB7_4_NV
GL_MAP1_VERTEX_ATTRIB8_4_NV = GL_MAP1_VERTEX_ATTRIB8_4_NV
GL_MAP1_VERTEX_ATTRIB9_4_NV = GL_MAP1_VERTEX_ATTRIB9_4_NV
GL_MAP2_BINORMAL_EXT = GL_MAP2_BINORMAL_EXT
GL_MAP2_COLOR_4 = GL_MAP2_COLOR_4
GL_MAP2_GRID_DOMAIN = GL_MAP2_GRID_DOMAIN
GL_MAP2_GRID_SEGMENTS = GL_MAP2_GRID_SEGMENTS
GL_MAP2_INDEX = GL_MAP2_INDEX
GL_MAP2_NORMAL = GL_MAP2_NORMAL
GL_MAP2_TANGENT_EXT = GL_MAP2_TANGENT_EXT
GL_MAP2_TEXTURE_COORD_1 = GL_MAP2_TEXTURE_COORD_1
GL_MAP2_TEXTURE_COORD_2 = GL_MAP2_TEXTURE_COORD_2
GL_MAP2_TEXTURE_COORD_3 = GL_MAP2_TEXTURE_COORD_3
GL_MAP2_TEXTURE_COORD_4 = GL_MAP2_TEXTURE_COORD_4
GL_MAP2_VERTEX_3 = GL_MAP2_VERTEX_3
GL_MAP2_VERTEX_4 = GL_MAP2_VERTEX_4
GL_MAP2_VERTEX_ATTRIB0_4_NV = GL_MAP2_VERTEX_ATTRIB0_4_NV
GL_MAP2_VERTEX_ATTRIB10_4_NV = GL_MAP2_VERTEX_ATTRIB10_4_NV
GL_MAP2_VERTEX_ATTRIB11_4_NV = GL_MAP2_VERTEX_ATTRIB11_4_NV
GL_MAP2_VERTEX_ATTRIB12_4_NV = GL_MAP2_VERTEX_ATTRIB12_4_NV
GL_MAP2_VERTEX_ATTRIB13_4_NV = GL_MAP2_VERTEX_ATTRIB13_4_NV
GL_MAP2_VERTEX_ATTRIB14_4_NV = GL_MAP2_VERTEX_ATTRIB14_4_NV
GL_MAP2_VERTEX_ATTRIB15_4_NV = GL_MAP2_VERTEX_ATTRIB15_4_NV
GL_MAP2_VERTEX_ATTRIB1_4_NV = GL_MAP2_VERTEX_ATTRIB1_4_NV
GL_MAP2_VERTEX_ATTRIB2_4_NV = GL_MAP2_VERTEX_ATTRIB2_4_NV
GL_MAP2_VERTEX_ATTRIB3_4_NV = GL_MAP2_VERTEX_ATTRIB3_4_NV
GL_MAP2_VERTEX_ATTRIB4_4_NV = GL_MAP2_VERTEX_ATTRIB4_4_NV
GL_MAP2_VERTEX_ATTRIB5_4_NV = GL_MAP2_VERTEX_ATTRIB5_4_NV
GL_MAP2_VERTEX_ATTRIB6_4_NV = GL_MAP2_VERTEX_ATTRIB6_4_NV
GL_MAP2_VERTEX_ATTRIB7_4_NV = GL_MAP2_VERTEX_ATTRIB7_4_NV
GL_MAP2_VERTEX_ATTRIB8_4_NV = GL_MAP2_VERTEX_ATTRIB8_4_NV
GL_MAP2_VERTEX_ATTRIB9_4_NV = GL_MAP2_VERTEX_ATTRIB9_4_NV
GL_MAP_ATTRIB_U_ORDER_NV = GL_MAP_ATTRIB_U_ORDER_NV
GL_MAP_ATTRIB_V_ORDER_NV = GL_MAP_ATTRIB_V_ORDER_NV
GL_MAP_COLOR = GL_MAP_COLOR
GL_MAP_STENCIL = GL_MAP_STENCIL
GL_MAP_TESSELLATION_NV = GL_MAP_TESSELLATION_NV
GL_MATERIAL_SIDE_HINT_PGI = GL_MATERIAL_SIDE_HINT_PGI
GL_MATRIX0_ARB = GL_MATRIX0_ARB
GL_MATRIX0_NV = GL_MATRIX0_NV
GL_MATRIX10_ARB = GL_MATRIX10_ARB
GL_MATRIX11_ARB = GL_MATRIX11_ARB
GL_MATRIX12_ARB = GL_MATRIX12_ARB
GL_MATRIX13_ARB = GL_MATRIX13_ARB
GL_MATRIX14_ARB = GL_MATRIX14_ARB
GL_MATRIX15_ARB = GL_MATRIX15_ARB
GL_MATRIX16_ARB = GL_MATRIX16_ARB
GL_MATRIX17_ARB = GL_MATRIX17_ARB
GL_MATRIX18_ARB = GL_MATRIX18_ARB
GL_MATRIX19_ARB = GL_MATRIX19_ARB
GL_MATRIX1_ARB = GL_MATRIX1_ARB
GL_MATRIX1_NV = GL_MATRIX1_NV
GL_MATRIX20_ARB = GL_MATRIX20_ARB
GL_MATRIX21_ARB = GL_MATRIX21_ARB
GL_MATRIX22_ARB = GL_MATRIX22_ARB
GL_MATRIX23_ARB = GL_MATRIX23_ARB
GL_MATRIX24_ARB = GL_MATRIX24_ARB
GL_MATRIX25_ARB = GL_MATRIX25_ARB
GL_MATRIX26_ARB = GL_MATRIX26_ARB
GL_MATRIX27_ARB = GL_MATRIX27_ARB
GL_MATRIX28_ARB = GL_MATRIX28_ARB
GL_MATRIX29_ARB = GL_MATRIX29_ARB
GL_MATRIX2_ARB = GL_MATRIX2_ARB
GL_MATRIX2_NV = GL_MATRIX2_NV
GL_MATRIX30_ARB = GL_MATRIX30_ARB
GL_MATRIX31_ARB = GL_MATRIX31_ARB
GL_MATRIX3_ARB = GL_MATRIX3_ARB
GL_MATRIX3_NV = GL_MATRIX3_NV
GL_MATRIX4_ARB = GL_MATRIX4_ARB
GL_MATRIX4_NV = GL_MATRIX4_NV
GL_MATRIX5_ARB = GL_MATRIX5_ARB
GL_MATRIX5_NV = GL_MATRIX5_NV
GL_MATRIX6_ARB = GL_MATRIX6_ARB
GL_MATRIX6_NV = GL_MATRIX6_NV
GL_MATRIX7_ARB = GL_MATRIX7_ARB
GL_MATRIX7_NV = GL_MATRIX7_NV
GL_MATRIX8_ARB = GL_MATRIX8_ARB
GL_MATRIX9_ARB = GL_MATRIX9_ARB
GL_MATRIX_EXT = GL_MATRIX_EXT
GL_MATRIX_INDEX_ARRAY_ARB = GL_MATRIX_INDEX_ARRAY_ARB
GL_MATRIX_INDEX_ARRAY_POINTER_ARB = GL_MATRIX_INDEX_ARRAY_POINTER_ARB
GL_MATRIX_INDEX_ARRAY_SIZE_ARB = GL_MATRIX_INDEX_ARRAY_SIZE_ARB
GL_MATRIX_INDEX_ARRAY_STRIDE_ARB = GL_MATRIX_INDEX_ARRAY_STRIDE_ARB
GL_MATRIX_INDEX_ARRAY_TYPE_ARB = GL_MATRIX_INDEX_ARRAY_TYPE_ARB
GL_MATRIX_MODE = GL_MATRIX_MODE
GL_MATRIX_PALETTE_ARB = GL_MATRIX_PALETTE_ARB
GL_MAT_AMBIENT_AND_DIFFUSE_BIT_PGI = GL_MAT_AMBIENT_AND_DIFFUSE_BIT_PGI
GL_MAT_AMBIENT_BIT_PGI = GL_MAT_AMBIENT_BIT_PGI
GL_MAT_COLOR_INDEXES_BIT_PGI = GL_MAT_COLOR_INDEXES_BIT_PGI
GL_MAT_DIFFUSE_BIT_PGI = GL_MAT_DIFFUSE_BIT_PGI
GL_MAT_EMISSION_BIT_PGI = GL_MAT_EMISSION_BIT_PGI
GL_MAT_SHININESS_BIT_PGI = GL_MAT_SHININESS_BIT_PGI
GL_MAT_SPECULAR_BIT_PGI = GL_MAT_SPECULAR_BIT_PGI
GL_MAX = GL_MAX
GL_MAX_3D_TEXTURE_SIZE = GL_MAX_3D_TEXTURE_SIZE
GL_MAX_3D_TEXTURE_SIZE_EXT = GL_MAX_3D_TEXTURE_SIZE_EXT
GL_MAX_4D_TEXTURE_SIZE_SGIS = GL_MAX_4D_TEXTURE_SIZE_SGIS
GL_MAX_ACTIVE_LIGHTS_SGIX = GL_MAX_ACTIVE_LIGHTS_SGIX
GL_MAX_ASYNC_DRAW_PIXELS_SGIX = GL_MAX_ASYNC_DRAW_PIXELS_SGIX
GL_MAX_ASYNC_HISTOGRAM_SGIX = GL_MAX_ASYNC_HISTOGRAM_SGIX
GL_MAX_ASYNC_READ_PIXELS_SGIX = GL_MAX_ASYNC_READ_PIXELS_SGIX
GL_MAX_ASYNC_TEX_IMAGE_SGIX = GL_MAX_ASYNC_TEX_IMAGE_SGIX
GL_MAX_ATTRIB_STACK_DEPTH = GL_MAX_ATTRIB_STACK_DEPTH
GL_MAX_CLIENT_ATTRIB_STACK_DEPTH = GL_MAX_CLIENT_ATTRIB_STACK_DEPTH
GL_MAX_CLIPMAP_DEPTH_SGIX = GL_MAX_CLIPMAP_DEPTH_SGIX
GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX = GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX
GL_MAX_CLIP_PLANES = GL_MAX_CLIP_PLANES
GL_MAX_COLOR_ATTACHMENTS_EXT = GL_MAX_COLOR_ATTACHMENTS_EXT
GL_MAX_COLOR_MATRIX_STACK_DEPTH = GL_MAX_COLOR_MATRIX_STACK_DEPTH
GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI = GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI
GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS = GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS
GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB = GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB
GL_MAX_CONVOLUTION_HEIGHT = GL_MAX_CONVOLUTION_HEIGHT
GL_MAX_CONVOLUTION_HEIGHT_EXT = GL_MAX_CONVOLUTION_HEIGHT_EXT
GL_MAX_CONVOLUTION_WIDTH = GL_MAX_CONVOLUTION_WIDTH
GL_MAX_CONVOLUTION_WIDTH_EXT = GL_MAX_CONVOLUTION_WIDTH_EXT
GL_MAX_CUBE_MAP_TEXTURE_SIZE = GL_MAX_CUBE_MAP_TEXTURE_SIZE
GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB = GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB
GL_MAX_CUBE_MAP_TEXTURE_SIZE_EXT = GL_MAX_CUBE_MAP_TEXTURE_SIZE_EXT
GL_MAX_DEFORMATION_ORDER_SGIX = GL_MAX_DEFORMATION_ORDER_SGIX
GL_MAX_DRAW_BUFFERS = GL_MAX_DRAW_BUFFERS
GL_MAX_DRAW_BUFFERS_ARB = GL_MAX_DRAW_BUFFERS_ARB
GL_MAX_DRAW_BUFFERS_ATI = GL_MAX_DRAW_BUFFERS_ATI
GL_MAX_ELEMENTS_INDICES = GL_MAX_ELEMENTS_INDICES
GL_MAX_ELEMENTS_INDICES_EXT = GL_MAX_ELEMENTS_INDICES_EXT
GL_MAX_ELEMENTS_VERTICES = GL_MAX_ELEMENTS_VERTICES
GL_MAX_ELEMENTS_VERTICES_EXT = GL_MAX_ELEMENTS_VERTICES_EXT
GL_MAX_EVAL_ORDER = GL_MAX_EVAL_ORDER
GL_MAX_EXT = GL_MAX_EXT
GL_MAX_FOG_FUNC_POINTS_SGIS = GL_MAX_FOG_FUNC_POINTS_SGIS
GL_MAX_FRAGMENT_LIGHTS_SGIX = GL_MAX_FRAGMENT_LIGHTS_SGIX
GL_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV = GL_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV
GL_MAX_FRAGMENT_UNIFORM_COMPONENTS = GL_MAX_FRAGMENT_UNIFORM_COMPONENTS
GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB = GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB
GL_MAX_FRAMEZOOM_FACTOR_SGIX = GL_MAX_FRAMEZOOM_FACTOR_SGIX
GL_MAX_GENERAL_COMBINERS_NV = GL_MAX_GENERAL_COMBINERS_NV
GL_MAX_LIGHTS = GL_MAX_LIGHTS
GL_MAX_LIST_NESTING = GL_MAX_LIST_NESTING
GL_MAX_MAP_TESSELLATION_NV = GL_MAX_MAP_TESSELLATION_NV
GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB = GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB
GL_MAX_MODELVIEW_STACK_DEPTH = GL_MAX_MODELVIEW_STACK_DEPTH
GL_MAX_NAME_STACK_DEPTH = GL_MAX_NAME_STACK_DEPTH
GL_MAX_OPTIMIZED_VERTEX_SHADER_INSTRUCTIONS_EXT = GL_MAX_OPTIMIZED_VERTEX_SHADER_INSTRUCTIONS_EXT
GL_MAX_OPTIMIZED_VERTEX_SHADER_INVARIANTS_EXT = GL_MAX_OPTIMIZED_VERTEX_SHADER_INVARIANTS_EXT
GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCALS_EXT = GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCALS_EXT
GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCAL_CONSTANTS_EXT = GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCAL_CONSTANTS_EXT
GL_MAX_OPTIMIZED_VERTEX_SHADER_VARIANTS_EXT = GL_MAX_OPTIMIZED_VERTEX_SHADER_VARIANTS_EXT
GL_MAX_PALETTE_MATRICES_ARB = GL_MAX_PALETTE_MATRICES_ARB
GL_MAX_PIXEL_MAP_TABLE = GL_MAX_PIXEL_MAP_TABLE
GL_MAX_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT = GL_MAX_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT
GL_MAX_PN_TRIANGLES_TESSELATION_LEVEL_ATI = GL_MAX_PN_TRIANGLES_TESSELATION_LEVEL_ATI
GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB = GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB
GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB = GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB
GL_MAX_PROGRAM_ATTRIBS_ARB = GL_MAX_PROGRAM_ATTRIBS_ARB
GL_MAX_PROGRAM_CALL_DEPTH_NV = GL_MAX_PROGRAM_CALL_DEPTH_NV
GL_MAX_PROGRAM_ENV_PARAMETERS_ARB = GL_MAX_PROGRAM_ENV_PARAMETERS_ARB
GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV = GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV
GL_MAX_PROGRAM_IF_DEPTH_NV = GL_MAX_PROGRAM_IF_DEPTH_NV
GL_MAX_PROGRAM_INSTRUCTIONS_ARB = GL_MAX_PROGRAM_INSTRUCTIONS_ARB
GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB = GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB
GL_MAX_PROGRAM_LOOP_COUNT_NV = GL_MAX_PROGRAM_LOOP_COUNT_NV
GL_MAX_PROGRAM_LOOP_DEPTH_NV = GL_MAX_PROGRAM_LOOP_DEPTH_NV
GL_MAX_PROGRAM_MATRICES_ARB = GL_MAX_PROGRAM_MATRICES_ARB
GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB = GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB
GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB = GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB
GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB = GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB
GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB = GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB
GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB = GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB
GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB = GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB
GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB = GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB
GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB = GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB
GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB = GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB
GL_MAX_PROGRAM_PARAMETERS_ARB = GL_MAX_PROGRAM_PARAMETERS_ARB
GL_MAX_PROGRAM_TEMPORARIES_ARB = GL_MAX_PROGRAM_TEMPORARIES_ARB
GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB = GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB
GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB = GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB
GL_MAX_PROJECTION_STACK_DEPTH = GL_MAX_PROJECTION_STACK_DEPTH
GL_MAX_RATIONAL_EVAL_ORDER_NV = GL_MAX_RATIONAL_EVAL_ORDER_NV
GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB = GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB
GL_MAX_RECTANGLE_TEXTURE_SIZE_NV = GL_MAX_RECTANGLE_TEXTURE_SIZE_NV
GL_MAX_RENDERBUFFER_SIZE_EXT = GL_MAX_RENDERBUFFER_SIZE_EXT
GL_MAX_SHININESS_NV = GL_MAX_SHININESS_NV
GL_MAX_SPOT_EXPONENT_NV = GL_MAX_SPOT_EXPONENT_NV
GL_MAX_TEXTURE_COORDS = GL_MAX_TEXTURE_COORDS
GL_MAX_TEXTURE_COORDS_ARB = GL_MAX_TEXTURE_COORDS_ARB
GL_MAX_TEXTURE_COORDS_NV = GL_MAX_TEXTURE_COORDS_NV
GL_MAX_TEXTURE_IMAGE_UNITS = GL_MAX_TEXTURE_IMAGE_UNITS
GL_MAX_TEXTURE_IMAGE_UNITS_ARB = GL_MAX_TEXTURE_IMAGE_UNITS_ARB
GL_MAX_TEXTURE_IMAGE_UNITS_NV = GL_MAX_TEXTURE_IMAGE_UNITS_NV
GL_MAX_TEXTURE_LOD_BIAS = GL_MAX_TEXTURE_LOD_BIAS
GL_MAX_TEXTURE_LOD_BIAS_EXT = GL_MAX_TEXTURE_LOD_BIAS_EXT
GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT = GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT
GL_MAX_TEXTURE_SIZE = GL_MAX_TEXTURE_SIZE
GL_MAX_TEXTURE_STACK_DEPTH = GL_MAX_TEXTURE_STACK_DEPTH
GL_MAX_TEXTURE_UNITS = GL_MAX_TEXTURE_UNITS
GL_MAX_TEXTURE_UNITS_ARB = GL_MAX_TEXTURE_UNITS_ARB
GL_MAX_TRACK_MATRICES_NV = GL_MAX_TRACK_MATRICES_NV
GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV = GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV
GL_MAX_VARYING_FLOATS = GL_MAX_VARYING_FLOATS
GL_MAX_VARYING_FLOATS_ARB = GL_MAX_VARYING_FLOATS_ARB
GL_MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV = GL_MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV
GL_MAX_VERTEX_ATTRIBS = GL_MAX_VERTEX_ATTRIBS
GL_MAX_VERTEX_ATTRIBS_ARB = GL_MAX_VERTEX_ATTRIBS_ARB
GL_MAX_VERTEX_HINT_PGI = GL_MAX_VERTEX_HINT_PGI
GL_MAX_VERTEX_SHADER_INSTRUCTIONS_EXT = GL_MAX_VERTEX_SHADER_INSTRUCTIONS_EXT
GL_MAX_VERTEX_SHADER_INVARIANTS_EXT = GL_MAX_VERTEX_SHADER_INVARIANTS_EXT
GL_MAX_VERTEX_SHADER_LOCALS_EXT = GL_MAX_VERTEX_SHADER_LOCALS_EXT
GL_MAX_VERTEX_SHADER_LOCAL_CONSTANTS_EXT = GL_MAX_VERTEX_SHADER_LOCAL_CONSTANTS_EXT
GL_MAX_VERTEX_SHADER_VARIANTS_EXT = GL_MAX_VERTEX_SHADER_VARIANTS_EXT
GL_MAX_VERTEX_STREAMS_ATI = GL_MAX_VERTEX_STREAMS_ATI
GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS = GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS
GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB = GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB
GL_MAX_VERTEX_UNIFORM_COMPONENTS = GL_MAX_VERTEX_UNIFORM_COMPONENTS
GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB = GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB
GL_MAX_VERTEX_UNITS_ARB = GL_MAX_VERTEX_UNITS_ARB
GL_MAX_VIEWPORT_DIMS = GL_MAX_VIEWPORT_DIMS
GL_MIN = GL_MIN
GL_MINMAX = GL_MINMAX
GL_MINMAX_EXT = GL_MINMAX_EXT
GL_MINMAX_FORMAT = GL_MINMAX_FORMAT
GL_MINMAX_FORMAT_EXT = GL_MINMAX_FORMAT_EXT
GL_MINMAX_SINK = GL_MINMAX_SINK
GL_MINMAX_SINK_EXT = GL_MINMAX_SINK_EXT
GL_MIN_EXT = GL_MIN_EXT
GL_MIRRORED_REPEAT = GL_MIRRORED_REPEAT
GL_MIRRORED_REPEAT_ARB = GL_MIRRORED_REPEAT_ARB
GL_MIRRORED_REPEAT_IBM = GL_MIRRORED_REPEAT_IBM
GL_MIRROR_CLAMP_ATI = GL_MIRROR_CLAMP_ATI
GL_MIRROR_CLAMP_EXT = GL_MIRROR_CLAMP_EXT
GL_MIRROR_CLAMP_TO_BORDER_EXT = GL_MIRROR_CLAMP_TO_BORDER_EXT
GL_MIRROR_CLAMP_TO_EDGE_ATI = GL_MIRROR_CLAMP_TO_EDGE_ATI
GL_MIRROR_CLAMP_TO_EDGE_EXT = GL_MIRROR_CLAMP_TO_EDGE_EXT
GL_MODELVIEW = GL_MODELVIEW
GL_MODELVIEW0_ARB = GL_MODELVIEW0_ARB
GL_MODELVIEW0_EXT = GL_MODELVIEW
GL_MODELVIEW0_MATRIX_EXT = GL_MODELVIEW_MATRIX
GL_MODELVIEW0_STACK_DEPTH_EXT = GL_MODELVIEW_STACK_DEPTH
GL_MODELVIEW10_ARB = GL_MODELVIEW10_ARB
GL_MODELVIEW11_ARB = GL_MODELVIEW11_ARB
GL_MODELVIEW12_ARB = GL_MODELVIEW12_ARB
GL_MODELVIEW13_ARB = GL_MODELVIEW13_ARB
GL_MODELVIEW14_ARB = GL_MODELVIEW14_ARB
GL_MODELVIEW15_ARB = GL_MODELVIEW15_ARB
GL_MODELVIEW16_ARB = GL_MODELVIEW16_ARB
GL_MODELVIEW17_ARB = GL_MODELVIEW17_ARB
GL_MODELVIEW18_ARB = GL_MODELVIEW18_ARB
GL_MODELVIEW19_ARB = GL_MODELVIEW19_ARB
GL_MODELVIEW1_ARB = GL_MODELVIEW1_ARB
GL_MODELVIEW1_EXT = GL_MODELVIEW1_EXT
GL_MODELVIEW1_MATRIX_EXT = GL_MODELVIEW1_MATRIX_EXT
GL_MODELVIEW1_STACK_DEPTH_EXT = GL_MODELVIEW1_STACK_DEPTH_EXT
GL_MODELVIEW20_ARB = GL_MODELVIEW20_ARB
GL_MODELVIEW21_ARB = GL_MODELVIEW21_ARB
GL_MODELVIEW22_ARB = GL_MODELVIEW22_ARB
GL_MODELVIEW23_ARB = GL_MODELVIEW23_ARB
GL_MODELVIEW24_ARB = GL_MODELVIEW24_ARB
GL_MODELVIEW25_ARB = GL_MODELVIEW25_ARB
GL_MODELVIEW26_ARB = GL_MODELVIEW26_ARB
GL_MODELVIEW27_ARB = GL_MODELVIEW27_ARB
GL_MODELVIEW28_ARB = GL_MODELVIEW28_ARB
GL_MODELVIEW29_ARB = GL_MODELVIEW29_ARB
GL_MODELVIEW2_ARB = GL_MODELVIEW2_ARB
GL_MODELVIEW30_ARB = GL_MODELVIEW30_ARB
GL_MODELVIEW31_ARB = GL_MODELVIEW31_ARB
GL_MODELVIEW3_ARB = GL_MODELVIEW3_ARB
GL_MODELVIEW4_ARB = GL_MODELVIEW4_ARB
GL_MODELVIEW5_ARB = GL_MODELVIEW5_ARB
GL_MODELVIEW6_ARB = GL_MODELVIEW6_ARB
GL_MODELVIEW7_ARB = GL_MODELVIEW7_ARB
GL_MODELVIEW8_ARB = GL_MODELVIEW8_ARB
GL_MODELVIEW9_ARB = GL_MODELVIEW9_ARB
GL_MODELVIEW_MATRIX = GL_MODELVIEW_MATRIX
GL_MODELVIEW_PROJECTION_NV = GL_MODELVIEW_PROJECTION_NV
GL_MODELVIEW_STACK_DEPTH = GL_MODELVIEW_STACK_DEPTH
GL_MODULATE = GL_MODULATE
GL_MODULATE_ADD_ATI = GL_MODULATE_ADD_ATI
GL_MODULATE_SIGNED_ADD_ATI = GL_MODULATE_SIGNED_ADD_ATI
GL_MODULATE_SUBTRACT_ATI = GL_MODULATE_SUBTRACT_ATI
GL_MOV_ATI = GL_MOV_ATI
GL_MULT = GL_MULT
GL_MULTISAMPLE = GL_MULTISAMPLE
GL_MULTISAMPLE_3DFX = GL_MULTISAMPLE_3DFX
GL_MULTISAMPLE_ARB = GL_MULTISAMPLE_ARB
GL_MULTISAMPLE_BIT = GL_MULTISAMPLE_BIT
GL_MULTISAMPLE_BIT_3DFX = GL_MULTISAMPLE_BIT_3DFX
GL_MULTISAMPLE_BIT_ARB = GL_MULTISAMPLE_BIT_ARB
GL_MULTISAMPLE_BIT_EXT = GL_MULTISAMPLE_BIT_EXT
GL_MULTISAMPLE_EXT = GL_MULTISAMPLE_EXT
GL_MULTISAMPLE_FILTER_HINT_NV = GL_MULTISAMPLE_FILTER_HINT_NV
GL_MULTISAMPLE_SGIS = GL_MULTISAMPLE_SGIS
GL_MUL_ATI = GL_MUL_ATI
GL_MVP_MATRIX_EXT = GL_MVP_MATRIX_EXT
GL_N3F_V3F = GL_N3F_V3F
GL_NAME_STACK_DEPTH = GL_NAME_STACK_DEPTH
GL_NAND = GL_NAND
GL_NATIVE_GRAPHICS_BEGIN_HINT_PGI = GL_NATIVE_GRAPHICS_BEGIN_HINT_PGI
GL_NATIVE_GRAPHICS_END_HINT_PGI = GL_NATIVE_GRAPHICS_END_HINT_PGI
GL_NATIVE_GRAPHICS_HANDLE_PGI = GL_NATIVE_GRAPHICS_HANDLE_PGI
GL_NEAREST = GL_NEAREST
GL_NEAREST_CLIPMAP_LINEAR_SGIX = GL_NEAREST_CLIPMAP_LINEAR_SGIX
GL_NEAREST_CLIPMAP_NEAREST_SGIX = GL_NEAREST_CLIPMAP_NEAREST_SGIX
GL_NEAREST_MIPMAP_LINEAR = GL_NEAREST_MIPMAP_LINEAR
GL_NEAREST_MIPMAP_NEAREST = GL_NEAREST_MIPMAP_NEAREST
GL_NEGATE_BIT_ATI = GL_NEGATE_BIT_ATI
GL_NEGATIVE_ONE_EXT = GL_NEGATIVE_ONE_EXT
GL_NEGATIVE_W_EXT = GL_NEGATIVE_W_EXT
GL_NEGATIVE_X_EXT = GL_NEGATIVE_X_EXT
GL_NEGATIVE_Y_EXT = GL_NEGATIVE_Y_EXT
GL_NEGATIVE_Z_EXT = GL_NEGATIVE_Z_EXT
GL_NEVER = GL_NEVER
GL_NICEST = GL_NICEST
GL_NONE = GL_NONE
GL_NOOP = GL_NOOP
GL_NOR = GL_NOR
GL_NORMALIZE = GL_NORMALIZE
GL_NORMALIZED_RANGE_EXT = GL_NORMALIZED_RANGE_EXT
GL_NORMAL_ARRAY = GL_NORMAL_ARRAY
GL_NORMAL_ARRAY_BUFFER_BINDING = GL_NORMAL_ARRAY_BUFFER_BINDING
GL_NORMAL_ARRAY_BUFFER_BINDING_ARB = GL_NORMAL_ARRAY_BUFFER_BINDING_ARB
GL_NORMAL_ARRAY_COUNT_EXT = GL_NORMAL_ARRAY_COUNT_EXT
GL_NORMAL_ARRAY_EXT = GL_NORMAL_ARRAY_EXT
GL_NORMAL_ARRAY_LIST_IBM = GL_NORMAL_ARRAY_LIST_IBM
GL_NORMAL_ARRAY_LIST_STRIDE_IBM = GL_NORMAL_ARRAY_LIST_STRIDE_IBM
GL_NORMAL_ARRAY_PARALLEL_POINTERS_INTEL = GL_NORMAL_ARRAY_PARALLEL_POINTERS_INTEL
GL_NORMAL_ARRAY_POINTER = GL_NORMAL_ARRAY_POINTER
GL_NORMAL_ARRAY_POINTER_EXT = GL_NORMAL_ARRAY_POINTER_EXT
GL_NORMAL_ARRAY_STRIDE = GL_NORMAL_ARRAY_STRIDE
GL_NORMAL_ARRAY_STRIDE_EXT = GL_NORMAL_ARRAY_STRIDE_EXT
GL_NORMAL_ARRAY_TYPE = GL_NORMAL_ARRAY_TYPE
GL_NORMAL_ARRAY_TYPE_EXT = GL_NORMAL_ARRAY_TYPE_EXT
GL_NORMAL_BIT_PGI = GL_NORMAL_BIT_PGI
GL_NORMAL_MAP = GL_NORMAL_MAP
GL_NORMAL_MAP_ARB = GL_NORMAL_MAP_ARB
GL_NORMAL_MAP_EXT = GL_NORMAL_MAP_EXT
GL_NORMAL_MAP_NV = GL_NORMAL_MAP_NV
GL_NOTEQUAL = GL_NOTEQUAL
GL_NO_ERROR = GL_NO_ERROR
GL_NUM_COMPRESSED_TEXTURE_FORMATS = GL_NUM_COMPRESSED_TEXTURE_FORMATS
GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB = GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB
GL_NUM_FRAGMENT_CONSTANTS_ATI = GL_NUM_FRAGMENT_CONSTANTS_ATI
GL_NUM_FRAGMENT_REGISTERS_ATI = GL_NUM_FRAGMENT_REGISTERS_ATI
GL_NUM_GENERAL_COMBINERS_NV = GL_NUM_GENERAL_COMBINERS_NV
GL_NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI = GL_NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI
GL_NUM_INSTRUCTIONS_PER_PASS_ATI = GL_NUM_INSTRUCTIONS_PER_PASS_ATI
GL_NUM_INSTRUCTIONS_TOTAL_ATI = GL_NUM_INSTRUCTIONS_TOTAL_ATI
GL_NUM_LOOPBACK_COMPONENTS_ATI = GL_NUM_LOOPBACK_COMPONENTS_ATI
GL_NUM_PASSES_ATI = GL_NUM_PASSES_ATI
GL_OBJECT_ACTIVE_ATTRIBUTES_ARB = GL_OBJECT_ACTIVE_ATTRIBUTES_ARB
GL_OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB = GL_OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB
GL_OBJECT_ACTIVE_UNIFORMS_ARB = GL_OBJECT_ACTIVE_UNIFORMS_ARB
GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB = GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB
GL_OBJECT_ATTACHED_OBJECTS_ARB = GL_OBJECT_ATTACHED_OBJECTS_ARB
GL_OBJECT_BUFFER_SIZE_ATI = GL_OBJECT_BUFFER_SIZE_ATI
GL_OBJECT_BUFFER_USAGE_ATI = GL_OBJECT_BUFFER_USAGE_ATI
GL_OBJECT_COMPILE_STATUS = GL_OBJECT_COMPILE_STATUS_ARB
GL_OBJECT_COMPILE_STATUS_ARB = GL_OBJECT_COMPILE_STATUS_ARB
GL_OBJECT_DELETE_STATUS_ARB = GL_OBJECT_DELETE_STATUS_ARB
GL_OBJECT_DISTANCE_TO_LINE_SGIS = GL_OBJECT_DISTANCE_TO_LINE_SGIS
GL_OBJECT_DISTANCE_TO_POINT_SGIS = GL_OBJECT_DISTANCE_TO_POINT_SGIS
GL_OBJECT_INFO_LOG_LENGTH_ARB = GL_OBJECT_INFO_LOG_LENGTH_ARB
GL_OBJECT_LINEAR = GL_OBJECT_LINEAR
GL_OBJECT_LINE_SGIS = GL_OBJECT_LINE_SGIS
GL_OBJECT_LINK_STATUS = GL_OBJECT_LINK_STATUS_ARB
GL_OBJECT_LINK_STATUS_ARB = GL_OBJECT_LINK_STATUS_ARB
GL_OBJECT_PLANE = GL_OBJECT_PLANE
GL_OBJECT_POINT_SGIS = GL_OBJECT_POINT_SGIS
GL_OBJECT_SHADER_SOURCE_LENGTH_ARB = GL_OBJECT_SHADER_SOURCE_LENGTH_ARB
GL_OBJECT_SUBTYPE_ARB = GL_OBJECT_SUBTYPE_ARB
GL_OBJECT_TYPE_ARB = GL_OBJECT_TYPE_ARB
GL_OBJECT_VALIDATE_STATUS_ARB = GL_OBJECT_VALIDATE_STATUS_ARB
GL_OCCLUSION_TEST_HP = GL_OCCLUSION_TEST_HP
GL_OCCLUSION_TEST_RESULT_HP = GL_OCCLUSION_TEST_RESULT_HP
GL_OFFSET_HILO_PROJECTIVE_TEXTURE_2D_NV = GL_OFFSET_HILO_PROJECTIVE_TEXTURE_2D_NV
GL_OFFSET_HILO_PROJECTIVE_TEXTURE_RECTANGLE_NV = GL_OFFSET_HILO_PROJECTIVE_TEXTURE_RECTANGLE_NV
GL_OFFSET_HILO_TEXTURE_2D_NV = GL_OFFSET_HILO_TEXTURE_2D_NV
GL_OFFSET_HILO_TEXTURE_RECTANGLE_NV = GL_OFFSET_HILO_TEXTURE_RECTANGLE_NV
GL_OFFSET_PROJECTIVE_TEXTURE_2D_NV = GL_OFFSET_PROJECTIVE_TEXTURE_2D_NV
GL_OFFSET_PROJECTIVE_TEXTURE_2D_SCALE_NV = GL_OFFSET_PROJECTIVE_TEXTURE_2D_SCALE_NV
GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_NV = GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_NV
GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_SCALE_NV = GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_SCALE_NV
GL_OFFSET_TEXTURE_2D_BIAS_NV = GL_OFFSET_TEXTURE_BIAS_NV
GL_OFFSET_TEXTURE_2D_MATRIX_NV = GL_OFFSET_TEXTURE_MATRIX_NV
GL_OFFSET_TEXTURE_2D_NV = GL_OFFSET_TEXTURE_2D_NV
GL_OFFSET_TEXTURE_2D_SCALE_NV = GL_OFFSET_TEXTURE_SCALE_NV
GL_OFFSET_TEXTURE_BIAS_NV = GL_OFFSET_TEXTURE_BIAS_NV
GL_OFFSET_TEXTURE_MATRIX_NV = GL_OFFSET_TEXTURE_MATRIX_NV
GL_OFFSET_TEXTURE_RECTANGLE_NV = GL_OFFSET_TEXTURE_RECTANGLE_NV
GL_OFFSET_TEXTURE_RECTANGLE_SCALE_NV = GL_OFFSET_TEXTURE_RECTANGLE_SCALE_NV
GL_OFFSET_TEXTURE_SCALE_NV = GL_OFFSET_TEXTURE_SCALE_NV
GL_ONE = GL_ONE
GL_ONE_EXT = GL_ONE_EXT
GL_ONE_MINUS_CONSTANT_ALPHA = GL_ONE_MINUS_CONSTANT_ALPHA
GL_ONE_MINUS_CONSTANT_ALPHA_EXT = GL_ONE_MINUS_CONSTANT_ALPHA_EXT
GL_ONE_MINUS_CONSTANT_COLOR = GL_ONE_MINUS_CONSTANT_COLOR
GL_ONE_MINUS_CONSTANT_COLOR_EXT = GL_ONE_MINUS_CONSTANT_COLOR_EXT
GL_ONE_MINUS_DST_ALPHA = GL_ONE_MINUS_DST_ALPHA
GL_ONE_MINUS_DST_COLOR = GL_ONE_MINUS_DST_COLOR
GL_ONE_MINUS_SRC_ALPHA = GL_ONE_MINUS_SRC_ALPHA
GL_ONE_MINUS_SRC_COLOR = GL_ONE_MINUS_SRC_COLOR
GL_OPERAND0_ALPHA = GL_OPERAND0_ALPHA
GL_OPERAND0_ALPHA_ARB = GL_OPERAND0_ALPHA_ARB
GL_OPERAND0_ALPHA_EXT = GL_OPERAND0_ALPHA_EXT
GL_OPERAND0_RGB = GL_OPERAND0_RGB
GL_OPERAND0_RGB_ARB = GL_OPERAND0_RGB_ARB
GL_OPERAND0_RGB_EXT = GL_OPERAND0_RGB_EXT
GL_OPERAND1_ALPHA = GL_OPERAND1_ALPHA
GL_OPERAND1_ALPHA_ARB = GL_OPERAND1_ALPHA_ARB
GL_OPERAND1_ALPHA_EXT = GL_OPERAND1_ALPHA_EXT
GL_OPERAND1_RGB = GL_OPERAND1_RGB
GL_OPERAND1_RGB_ARB = GL_OPERAND1_RGB_ARB
GL_OPERAND1_RGB_EXT = GL_OPERAND1_RGB_EXT
GL_OPERAND2_ALPHA = GL_OPERAND2_ALPHA
GL_OPERAND2_ALPHA_ARB = GL_OPERAND2_ALPHA_ARB
GL_OPERAND2_ALPHA_EXT = GL_OPERAND2_ALPHA_EXT
GL_OPERAND2_RGB = GL_OPERAND2_RGB
GL_OPERAND2_RGB_ARB = GL_OPERAND2_RGB_ARB
GL_OPERAND2_RGB_EXT = GL_OPERAND2_RGB_EXT
GL_OPERAND3_ALPHA_NV = GL_OPERAND3_ALPHA_NV
GL_OPERAND3_RGB_NV = GL_OPERAND3_RGB_NV
GL_OP_ADD_EXT = GL_OP_ADD_EXT
GL_OP_CLAMP_EXT = GL_OP_CLAMP_EXT
GL_OP_CROSS_PRODUCT_EXT = GL_OP_CROSS_PRODUCT_EXT
GL_OP_DOT3_EXT = GL_OP_DOT3_EXT
GL_OP_DOT4_EXT = GL_OP_DOT4_EXT
GL_OP_EXP_BASE_2_EXT = GL_OP_EXP_BASE_2_EXT
GL_OP_FLOOR_EXT = GL_OP_FLOOR_EXT
GL_OP_FRAC_EXT = GL_OP_FRAC_EXT
GL_OP_INDEX_EXT = GL_OP_INDEX_EXT
GL_OP_LOG_BASE_2_EXT = GL_OP_LOG_BASE_2_EXT
GL_OP_MADD_EXT = GL_OP_MADD_EXT
GL_OP_MAX_EXT = GL_OP_MAX_EXT
GL_OP_MIN_EXT = GL_OP_MIN_EXT
GL_OP_MOV_EXT = GL_OP_MOV_EXT
GL_OP_MULTIPLY_MATRIX_EXT = GL_OP_MULTIPLY_MATRIX_EXT
GL_OP_MUL_EXT = GL_OP_MUL_EXT
GL_OP_NEGATE_EXT = GL_OP_NEGATE_EXT
GL_OP_POWER_EXT = GL_OP_POWER_EXT
GL_OP_RECIP_EXT = GL_OP_RECIP_EXT
GL_OP_RECIP_SQRT_EXT = GL_OP_RECIP_SQRT_EXT
GL_OP_ROUND_EXT = GL_OP_ROUND_EXT
GL_OP_SET_GE_EXT = GL_OP_SET_GE_EXT
GL_OP_SET_LT_EXT = GL_OP_SET_LT_EXT
GL_OP_SUB_EXT = GL_OP_SUB_EXT
GL_OR = GL_OR
GL_ORDER = GL_ORDER
GL_OR_INVERTED = GL_OR_INVERTED
GL_OR_REVERSE = GL_OR_REVERSE
GL_OUTPUT_COLOR0_EXT = GL_OUTPUT_COLOR0_EXT
GL_OUTPUT_COLOR1_EXT = GL_OUTPUT_COLOR1_EXT
GL_OUTPUT_FOG_EXT = GL_OUTPUT_FOG_EXT
GL_OUTPUT_TEXTURE_COORD0_EXT = GL_OUTPUT_TEXTURE_COORD0_EXT
GL_OUTPUT_TEXTURE_COORD10_EXT = GL_OUTPUT_TEXTURE_COORD10_EXT
GL_OUTPUT_TEXTURE_COORD11_EXT = GL_OUTPUT_TEXTURE_COORD11_EXT
GL_OUTPUT_TEXTURE_COORD12_EXT = GL_OUTPUT_TEXTURE_COORD12_EXT
GL_OUTPUT_TEXTURE_COORD13_EXT = GL_OUTPUT_TEXTURE_COORD13_EXT
GL_OUTPUT_TEXTURE_COORD14_EXT = GL_OUTPUT_TEXTURE_COORD14_EXT
GL_OUTPUT_TEXTURE_COORD15_EXT = GL_OUTPUT_TEXTURE_COORD15_EXT
GL_OUTPUT_TEXTURE_COORD16_EXT = GL_OUTPUT_TEXTURE_COORD16_EXT
GL_OUTPUT_TEXTURE_COORD17_EXT = GL_OUTPUT_TEXTURE_COORD17_EXT
GL_OUTPUT_TEXTURE_COORD18_EXT = GL_OUTPUT_TEXTURE_COORD18_EXT
GL_OUTPUT_TEXTURE_COORD19_EXT = GL_OUTPUT_TEXTURE_COORD19_EXT
GL_OUTPUT_TEXTURE_COORD1_EXT = GL_OUTPUT_TEXTURE_COORD1_EXT
GL_OUTPUT_TEXTURE_COORD20_EXT = GL_OUTPUT_TEXTURE_COORD20_EXT
GL_OUTPUT_TEXTURE_COORD21_EXT = GL_OUTPUT_TEXTURE_COORD21_EXT
GL_OUTPUT_TEXTURE_COORD22_EXT = GL_OUTPUT_TEXTURE_COORD22_EXT
GL_OUTPUT_TEXTURE_COORD23_EXT = GL_OUTPUT_TEXTURE_COORD23_EXT
GL_OUTPUT_TEXTURE_COORD24_EXT = GL_OUTPUT_TEXTURE_COORD24_EXT
GL_OUTPUT_TEXTURE_COORD25_EXT = GL_OUTPUT_TEXTURE_COORD25_EXT
GL_OUTPUT_TEXTURE_COORD26_EXT = GL_OUTPUT_TEXTURE_COORD26_EXT
GL_OUTPUT_TEXTURE_COORD27_EXT = GL_OUTPUT_TEXTURE_COORD27_EXT
GL_OUTPUT_TEXTURE_COORD28_EXT = GL_OUTPUT_TEXTURE_COORD28_EXT
GL_OUTPUT_TEXTURE_COORD29_EXT = GL_OUTPUT_TEXTURE_COORD29_EXT
GL_OUTPUT_TEXTURE_COORD2_EXT = GL_OUTPUT_TEXTURE_COORD2_EXT
GL_OUTPUT_TEXTURE_COORD30_EXT = GL_OUTPUT_TEXTURE_COORD30_EXT
GL_OUTPUT_TEXTURE_COORD31_EXT = GL_OUTPUT_TEXTURE_COORD31_EXT
GL_OUTPUT_TEXTURE_COORD3_EXT = GL_OUTPUT_TEXTURE_COORD3_EXT
GL_OUTPUT_TEXTURE_COORD4_EXT = GL_OUTPUT_TEXTURE_COORD4_EXT
GL_OUTPUT_TEXTURE_COORD5_EXT = GL_OUTPUT_TEXTURE_COORD5_EXT
GL_OUTPUT_TEXTURE_COORD6_EXT = GL_OUTPUT_TEXTURE_COORD6_EXT
GL_OUTPUT_TEXTURE_COORD7_EXT = GL_OUTPUT_TEXTURE_COORD7_EXT
GL_OUTPUT_TEXTURE_COORD8_EXT = GL_OUTPUT_TEXTURE_COORD8_EXT
GL_OUTPUT_TEXTURE_COORD9_EXT = GL_OUTPUT_TEXTURE_COORD9_EXT
GL_OUTPUT_VERTEX_EXT = GL_OUTPUT_VERTEX_EXT
GL_OUT_OF_MEMORY = GL_OUT_OF_MEMORY
GL_PACK_ALIGNMENT = GL_PACK_ALIGNMENT
GL_PACK_CMYK_HINT_EXT = GL_PACK_CMYK_HINT_EXT
GL_PACK_IMAGE_DEPTH_SGIS = GL_PACK_IMAGE_DEPTH_SGIS
GL_PACK_IMAGE_HEIGHT = GL_PACK_IMAGE_HEIGHT
GL_PACK_IMAGE_HEIGHT_EXT = GL_PACK_IMAGE_HEIGHT_EXT
GL_PACK_INVERT_MESA = GL_PACK_INVERT_MESA
GL_PACK_LSB_FIRST = GL_PACK_LSB_FIRST
GL_PACK_RESAMPLE_OML = GL_PACK_RESAMPLE_OML
GL_PACK_RESAMPLE_SGIX = GL_PACK_RESAMPLE_SGIX
GL_PACK_ROW_LENGTH = GL_PACK_ROW_LENGTH
GL_PACK_SKIP_IMAGES = GL_PACK_SKIP_IMAGES
GL_PACK_SKIP_IMAGES_EXT = GL_PACK_SKIP_IMAGES_EXT
GL_PACK_SKIP_PIXELS = GL_PACK_SKIP_PIXELS
GL_PACK_SKIP_ROWS = GL_PACK_SKIP_ROWS
GL_PACK_SKIP_VOLUMES_SGIS = GL_PACK_SKIP_VOLUMES_SGIS
GL_PACK_SUBSAMPLE_RATE_SGIX = GL_PACK_SUBSAMPLE_RATE_SGIX
GL_PACK_SWAP_BYTES = GL_PACK_SWAP_BYTES
GL_PARALLEL_ARRAYS_INTEL = GL_PARALLEL_ARRAYS_INTEL
GL_PASS_THROUGH_NV = GL_PASS_THROUGH_NV
GL_PASS_THROUGH_TOKEN = GL_PASS_THROUGH_TOKEN
GL_PERSPECTIVE_CORRECTION_HINT = GL_PERSPECTIVE_CORRECTION_HINT
GL_PERTURB_EXT = GL_PERTURB_EXT
GL_PER_STAGE_CONSTANTS_NV = GL_PER_STAGE_CONSTANTS_NV
GL_PHONG_HINT_WIN = GL_PHONG_HINT_WIN
GL_PHONG_WIN = GL_PHONG_WIN
GL_PIXEL_COUNTER_BITS_NV = GL_PIXEL_COUNTER_BITS_NV
GL_PIXEL_COUNT_AVAILABLE_NV = GL_PIXEL_COUNT_AVAILABLE_NV
GL_PIXEL_COUNT_NV = GL_PIXEL_COUNT_NV
GL_PIXEL_CUBIC_WEIGHT_EXT = GL_PIXEL_CUBIC_WEIGHT_EXT
GL_PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS = GL_PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS
GL_PIXEL_FRAGMENT_RGB_SOURCE_SGIS = GL_PIXEL_FRAGMENT_RGB_SOURCE_SGIS
GL_PIXEL_GROUP_COLOR_SGIS = GL_PIXEL_GROUP_COLOR_SGIS
GL_PIXEL_MAG_FILTER_EXT = GL_PIXEL_MAG_FILTER_EXT
GL_PIXEL_MAP_A_TO_A = GL_PIXEL_MAP_A_TO_A
GL_PIXEL_MAP_A_TO_A_SIZE = GL_PIXEL_MAP_A_TO_A_SIZE
GL_PIXEL_MAP_B_TO_B = GL_PIXEL_MAP_B_TO_B
GL_PIXEL_MAP_B_TO_B_SIZE = GL_PIXEL_MAP_B_TO_B_SIZE
GL_PIXEL_MAP_G_TO_G = GL_PIXEL_MAP_G_TO_G
GL_PIXEL_MAP_G_TO_G_SIZE = GL_PIXEL_MAP_G_TO_G_SIZE
GL_PIXEL_MAP_I_TO_A = GL_PIXEL_MAP_I_TO_A
GL_PIXEL_MAP_I_TO_A_SIZE = GL_PIXEL_MAP_I_TO_A_SIZE
GL_PIXEL_MAP_I_TO_B = GL_PIXEL_MAP_I_TO_B
GL_PIXEL_MAP_I_TO_B_SIZE = GL_PIXEL_MAP_I_TO_B_SIZE
GL_PIXEL_MAP_I_TO_G = GL_PIXEL_MAP_I_TO_G
GL_PIXEL_MAP_I_TO_G_SIZE = GL_PIXEL_MAP_I_TO_G_SIZE
GL_PIXEL_MAP_I_TO_I = GL_PIXEL_MAP_I_TO_I
GL_PIXEL_MAP_I_TO_I_SIZE = GL_PIXEL_MAP_I_TO_I_SIZE
GL_PIXEL_MAP_I_TO_R = GL_PIXEL_MAP_I_TO_R
GL_PIXEL_MAP_I_TO_R_SIZE = GL_PIXEL_MAP_I_TO_R_SIZE
GL_PIXEL_MAP_R_TO_R = GL_PIXEL_MAP_R_TO_R
GL_PIXEL_MAP_R_TO_R_SIZE = GL_PIXEL_MAP_R_TO_R_SIZE
GL_PIXEL_MAP_S_TO_S = GL_PIXEL_MAP_S_TO_S
GL_PIXEL_MAP_S_TO_S_SIZE = GL_PIXEL_MAP_S_TO_S_SIZE
GL_PIXEL_MIN_FILTER_EXT = GL_PIXEL_MIN_FILTER_EXT
GL_PIXEL_MODE_BIT = GL_PIXEL_MODE_BIT
GL_PIXEL_PACK_BUFFER = GL_PIXEL_PACK_BUFFER
GL_PIXEL_PACK_BUFFER_ARB = GL_PIXEL_PACK_BUFFER_ARB
GL_PIXEL_PACK_BUFFER_BINDING = GL_PIXEL_PACK_BUFFER_BINDING
GL_PIXEL_PACK_BUFFER_BINDING_ARB = GL_PIXEL_PACK_BUFFER_BINDING_ARB
GL_PIXEL_PACK_BUFFER_BINDING_EXT = GL_PIXEL_PACK_BUFFER_BINDING_EXT
GL_PIXEL_PACK_BUFFER_EXT = GL_PIXEL_PACK_BUFFER_EXT
GL_PIXEL_SUBSAMPLE_2424_SGIX = GL_PIXEL_SUBSAMPLE_2424_SGIX
GL_PIXEL_SUBSAMPLE_4242_SGIX = GL_PIXEL_SUBSAMPLE_4242_SGIX
GL_PIXEL_SUBSAMPLE_4444_SGIX = GL_PIXEL_SUBSAMPLE_4444_SGIX
GL_PIXEL_TEXTURE_SGIS = GL_PIXEL_TEXTURE_SGIS
GL_PIXEL_TEX_GEN_ALPHA_LS_SGIX = GL_PIXEL_TEX_GEN_ALPHA_LS_SGIX
GL_PIXEL_TEX_GEN_ALPHA_MS_SGIX = GL_PIXEL_TEX_GEN_ALPHA_MS_SGIX
GL_PIXEL_TEX_GEN_ALPHA_NO_REPLACE_SGIX = GL_PIXEL_TEX_GEN_ALPHA_NO_REPLACE_SGIX
GL_PIXEL_TEX_GEN_ALPHA_REPLACE_SGIX = GL_PIXEL_TEX_GEN_ALPHA_REPLACE_SGIX
GL_PIXEL_TEX_GEN_MODE_SGIX = GL_PIXEL_TEX_GEN_MODE_SGIX
GL_PIXEL_TEX_GEN_Q_CEILING_SGIX = GL_PIXEL_TEX_GEN_Q_CEILING_SGIX
GL_PIXEL_TEX_GEN_Q_FLOOR_SGIX = GL_PIXEL_TEX_GEN_Q_FLOOR_SGIX
GL_PIXEL_TEX_GEN_Q_ROUND_SGIX = GL_PIXEL_TEX_GEN_Q_ROUND_SGIX
GL_PIXEL_TEX_GEN_SGIX = GL_PIXEL_TEX_GEN_SGIX
GL_PIXEL_TILE_BEST_ALIGNMENT_SGIX = GL_PIXEL_TILE_BEST_ALIGNMENT_SGIX
GL_PIXEL_TILE_CACHE_INCREMENT_SGIX = GL_PIXEL_TILE_CACHE_INCREMENT_SGIX
GL_PIXEL_TILE_CACHE_SIZE_SGIX = GL_PIXEL_TILE_CACHE_SIZE_SGIX
GL_PIXEL_TILE_GRID_DEPTH_SGIX = GL_PIXEL_TILE_GRID_DEPTH_SGIX
GL_PIXEL_TILE_GRID_HEIGHT_SGIX = GL_PIXEL_TILE_GRID_HEIGHT_SGIX
GL_PIXEL_TILE_GRID_WIDTH_SGIX = GL_PIXEL_TILE_GRID_WIDTH_SGIX
GL_PIXEL_TILE_HEIGHT_SGIX = GL_PIXEL_TILE_HEIGHT_SGIX
GL_PIXEL_TILE_WIDTH_SGIX = GL_PIXEL_TILE_WIDTH_SGIX
GL_PIXEL_TRANSFORM_2D_EXT = GL_PIXEL_TRANSFORM_2D_EXT
GL_PIXEL_TRANSFORM_2D_MATRIX_EXT = GL_PIXEL_TRANSFORM_2D_MATRIX_EXT
GL_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT = GL_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT
GL_PIXEL_UNPACK_BUFFER = GL_PIXEL_UNPACK_BUFFER
GL_PIXEL_UNPACK_BUFFER_ARB = GL_PIXEL_UNPACK_BUFFER_ARB
GL_PIXEL_UNPACK_BUFFER_BINDING = GL_PIXEL_UNPACK_BUFFER_BINDING
GL_PIXEL_UNPACK_BUFFER_BINDING_ARB = GL_PIXEL_UNPACK_BUFFER_BINDING_ARB
GL_PIXEL_UNPACK_BUFFER_BINDING_EXT = GL_PIXEL_UNPACK_BUFFER_BINDING_EXT
GL_PIXEL_UNPACK_BUFFER_EXT = GL_PIXEL_UNPACK_BUFFER_EXT
GL_PN_TRIANGLES_ATI = GL_PN_TRIANGLES_ATI
GL_PN_TRIANGLES_NORMAL_MODE_ATI = GL_PN_TRIANGLES_NORMAL_MODE_ATI
GL_PN_TRIANGLES_NORMAL_MODE_LINEAR_ATI = GL_PN_TRIANGLES_NORMAL_MODE_LINEAR_ATI
GL_PN_TRIANGLES_NORMAL_MODE_QUADRATIC_ATI = GL_PN_TRIANGLES_NORMAL_MODE_QUADRATIC_ATI
GL_PN_TRIANGLES_POINT_MODE_ATI = GL_PN_TRIANGLES_POINT_MODE_ATI
GL_PN_TRIANGLES_POINT_MODE_CUBIC_ATI = GL_PN_TRIANGLES_POINT_MODE_CUBIC_ATI
GL_PN_TRIANGLES_POINT_MODE_LINEAR_ATI = GL_PN_TRIANGLES_POINT_MODE_LINEAR_ATI
GL_PN_TRIANGLES_TESSELATION_LEVEL_ATI = GL_PN_TRIANGLES_TESSELATION_LEVEL_ATI
GL_POINT = GL_POINT
GL_POINTS = GL_POINTS
GL_POINT_BIT = GL_POINT_BIT
GL_POINT_DISTANCE_ATTENUATION = GL_POINT_DISTANCE_ATTENUATION
GL_POINT_DISTANCE_ATTENUATION_ARB = GL_POINT_DISTANCE_ATTENUATION_ARB
GL_POINT_FADE_THRESHOLD_SIZE = GL_POINT_FADE_THRESHOLD_SIZE
GL_POINT_FADE_THRESHOLD_SIZE_ARB = GL_POINT_FADE_THRESHOLD_SIZE_ARB
GL_POINT_FADE_THRESHOLD_SIZE_EXT = GL_POINT_FADE_THRESHOLD_SIZE_EXT
GL_POINT_FADE_THRESHOLD_SIZE_SGIS = GL_POINT_FADE_THRESHOLD_SIZE_SGIS
GL_POINT_SIZE = GL_POINT_SIZE
GL_POINT_SIZE_GRANULARITY = GL_SMOOTH_POINT_SIZE_GRANULARITY
GL_POINT_SIZE_MAX = GL_POINT_SIZE_MAX
GL_POINT_SIZE_MAX_ARB = GL_POINT_SIZE_MAX_ARB
GL_POINT_SIZE_MAX_EXT = GL_POINT_SIZE_MAX_EXT
GL_POINT_SIZE_MAX_SGIS = GL_POINT_SIZE_MAX_SGIS
GL_POINT_SIZE_MIN = GL_POINT_SIZE_MIN
GL_POINT_SIZE_MIN_ARB = GL_POINT_SIZE_MIN_ARB
GL_POINT_SIZE_MIN_EXT = GL_POINT_SIZE_MIN_EXT
GL_POINT_SIZE_MIN_SGIS = GL_POINT_SIZE_MIN_SGIS
GL_POINT_SIZE_RANGE = GL_SMOOTH_POINT_SIZE_RANGE
GL_POINT_SMOOTH = GL_POINT_SMOOTH
GL_POINT_SMOOTH_HINT = GL_POINT_SMOOTH_HINT
GL_POINT_SPRITE = GL_POINT_SPRITE
GL_POINT_SPRITE_ARB = GL_POINT_SPRITE_ARB
GL_POINT_SPRITE_COORD_ORIGIN = GL_POINT_SPRITE_COORD_ORIGIN
GL_POINT_SPRITE_NV = GL_POINT_SPRITE_NV
GL_POINT_SPRITE_R_MODE_NV = GL_POINT_SPRITE_R_MODE_NV
GL_POINT_TOKEN = GL_POINT_TOKEN
GL_POLYGON = GL_POLYGON
GL_POLYGON_BIT = GL_POLYGON_BIT
GL_POLYGON_MODE = GL_POLYGON_MODE
GL_POLYGON_OFFSET_BIAS_EXT = GL_POLYGON_OFFSET_BIAS_EXT
GL_POLYGON_OFFSET_EXT = GL_POLYGON_OFFSET_EXT
GL_POLYGON_OFFSET_FACTOR = GL_POLYGON_OFFSET_FACTOR
GL_POLYGON_OFFSET_FACTOR_EXT = GL_POLYGON_OFFSET_FACTOR_EXT
GL_POLYGON_OFFSET_FILL = GL_POLYGON_OFFSET_FILL
GL_POLYGON_OFFSET_LINE = GL_POLYGON_OFFSET_LINE
GL_POLYGON_OFFSET_POINT = GL_POLYGON_OFFSET_POINT
GL_POLYGON_OFFSET_UNITS = GL_POLYGON_OFFSET_UNITS
GL_POLYGON_SMOOTH = GL_POLYGON_SMOOTH
GL_POLYGON_SMOOTH_HINT = GL_POLYGON_SMOOTH_HINT
GL_POLYGON_STIPPLE = GL_POLYGON_STIPPLE
GL_POLYGON_STIPPLE_BIT = GL_POLYGON_STIPPLE_BIT
GL_POLYGON_TOKEN = GL_POLYGON_TOKEN
GL_POSITION = GL_POSITION
GL_POST_COLOR_MATRIX_ALPHA_BIAS = GL_POST_COLOR_MATRIX_ALPHA_BIAS
GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI = GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI
GL_POST_COLOR_MATRIX_ALPHA_SCALE = GL_POST_COLOR_MATRIX_ALPHA_SCALE
GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI = GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI
GL_POST_COLOR_MATRIX_BLUE_BIAS = GL_POST_COLOR_MATRIX_BLUE_BIAS
GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI = GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI
GL_POST_COLOR_MATRIX_BLUE_SCALE = GL_POST_COLOR_MATRIX_BLUE_SCALE
GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI = GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI
GL_POST_COLOR_MATRIX_COLOR_TABLE = GL_POST_COLOR_MATRIX_COLOR_TABLE
GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI = GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI
GL_POST_COLOR_MATRIX_GREEN_BIAS = GL_POST_COLOR_MATRIX_GREEN_BIAS
GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI = GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI
GL_POST_COLOR_MATRIX_GREEN_SCALE = GL_POST_COLOR_MATRIX_GREEN_SCALE
GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI = GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI
GL_POST_COLOR_MATRIX_RED_BIAS = GL_POST_COLOR_MATRIX_RED_BIAS
GL_POST_COLOR_MATRIX_RED_BIAS_SGI = GL_POST_COLOR_MATRIX_RED_BIAS_SGI
GL_POST_COLOR_MATRIX_RED_SCALE = GL_POST_COLOR_MATRIX_RED_SCALE
GL_POST_COLOR_MATRIX_RED_SCALE_SGI = GL_POST_COLOR_MATRIX_RED_SCALE_SGI
GL_POST_CONVOLUTION_ALPHA_BIAS = GL_POST_CONVOLUTION_ALPHA_BIAS
GL_POST_CONVOLUTION_ALPHA_BIAS_EXT = GL_POST_CONVOLUTION_ALPHA_BIAS_EXT
GL_POST_CONVOLUTION_ALPHA_SCALE = GL_POST_CONVOLUTION_ALPHA_SCALE
GL_POST_CONVOLUTION_ALPHA_SCALE_EXT = GL_POST_CONVOLUTION_ALPHA_SCALE_EXT
GL_POST_CONVOLUTION_BLUE_BIAS = GL_POST_CONVOLUTION_BLUE_BIAS
GL_POST_CONVOLUTION_BLUE_BIAS_EXT = GL_POST_CONVOLUTION_BLUE_BIAS_EXT
GL_POST_CONVOLUTION_BLUE_SCALE = GL_POST_CONVOLUTION_BLUE_SCALE
GL_POST_CONVOLUTION_BLUE_SCALE_EXT = GL_POST_CONVOLUTION_BLUE_SCALE_EXT
GL_POST_CONVOLUTION_COLOR_TABLE = GL_POST_CONVOLUTION_COLOR_TABLE
GL_POST_CONVOLUTION_COLOR_TABLE_SGI = GL_POST_CONVOLUTION_COLOR_TABLE_SGI
GL_POST_CONVOLUTION_GREEN_BIAS = GL_POST_CONVOLUTION_GREEN_BIAS
GL_POST_CONVOLUTION_GREEN_BIAS_EXT = GL_POST_CONVOLUTION_GREEN_BIAS_EXT
GL_POST_CONVOLUTION_GREEN_SCALE = GL_POST_CONVOLUTION_GREEN_SCALE
GL_POST_CONVOLUTION_GREEN_SCALE_EXT = GL_POST_CONVOLUTION_GREEN_SCALE_EXT
GL_POST_CONVOLUTION_RED_BIAS = GL_POST_CONVOLUTION_RED_BIAS
GL_POST_CONVOLUTION_RED_BIAS_EXT = GL_POST_CONVOLUTION_RED_BIAS_EXT
GL_POST_CONVOLUTION_RED_SCALE = GL_POST_CONVOLUTION_RED_SCALE
GL_POST_CONVOLUTION_RED_SCALE_EXT = GL_POST_CONVOLUTION_RED_SCALE_EXT
GL_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP = GL_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP
GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX = GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX
GL_POST_TEXTURE_FILTER_BIAS_SGIX = GL_POST_TEXTURE_FILTER_BIAS_SGIX
GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX = GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX
GL_POST_TEXTURE_FILTER_SCALE_SGIX = GL_POST_TEXTURE_FILTER_SCALE_SGIX
GL_PREFER_DOUBLEBUFFER_HINT_PGI = GL_PREFER_DOUBLEBUFFER_HINT_PGI
GL_PRESERVE_ATI = GL_PRESERVE_ATI
GL_PREVIOUS = GL_PREVIOUS
GL_PREVIOUS_ARB = GL_PREVIOUS_ARB
GL_PREVIOUS_EXT = GL_PREVIOUS_EXT
GL_PREVIOUS_TEXTURE_INPUT_NV = GL_PREVIOUS_TEXTURE_INPUT_NV
GL_PRIMARY_COLOR = GL_PRIMARY_COLOR
GL_PRIMARY_COLOR_ARB = GL_PRIMARY_COLOR_ARB
GL_PRIMARY_COLOR_EXT = GL_PRIMARY_COLOR_EXT
GL_PRIMARY_COLOR_NV = GL_PRIMARY_COLOR_NV
GL_PRIMITIVE_RESTART_INDEX_NV = GL_PRIMITIVE_RESTART_INDEX_NV
GL_PRIMITIVE_RESTART_NV = GL_PRIMITIVE_RESTART_NV
GL_PROGRAM_ADDRESS_REGISTERS_ARB = GL_PROGRAM_ADDRESS_REGISTERS_ARB
GL_PROGRAM_ALU_INSTRUCTIONS_ARB = GL_PROGRAM_ALU_INSTRUCTIONS_ARB
GL_PROGRAM_ATTRIBS_ARB = GL_PROGRAM_ATTRIBS_ARB
GL_PROGRAM_BINDING_ARB = GL_PROGRAM_BINDING_ARB
GL_PROGRAM_ERROR_POSITION_ARB = GL_PROGRAM_ERROR_POSITION_ARB
GL_PROGRAM_ERROR_POSITION_NV = GL_PROGRAM_ERROR_POSITION_NV
GL_PROGRAM_ERROR_STRING_ARB = GL_PROGRAM_ERROR_STRING_ARB
GL_PROGRAM_ERROR_STRING_NV = GL_PROGRAM_ERROR_STRING_NV
GL_PROGRAM_FORMAT_ARB = GL_PROGRAM_FORMAT_ARB
GL_PROGRAM_FORMAT_ASCII_ARB = GL_PROGRAM_FORMAT_ASCII_ARB
GL_PROGRAM_INSTRUCTIONS_ARB = GL_PROGRAM_INSTRUCTIONS_ARB
GL_PROGRAM_LENGTH_ARB = GL_PROGRAM_LENGTH_ARB
GL_PROGRAM_LENGTH_NV = GL_PROGRAM_LENGTH_NV
GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB = GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB
GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB = GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB
GL_PROGRAM_NATIVE_ATTRIBS_ARB = GL_PROGRAM_NATIVE_ATTRIBS_ARB
GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB = GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB
GL_PROGRAM_NATIVE_PARAMETERS_ARB = GL_PROGRAM_NATIVE_PARAMETERS_ARB
GL_PROGRAM_NATIVE_TEMPORARIES_ARB = GL_PROGRAM_NATIVE_TEMPORARIES_ARB
GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB = GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB
GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB = GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB
GL_PROGRAM_OBJECT_ARB = GL_PROGRAM_OBJECT_ARB
GL_PROGRAM_PARAMETERS_ARB = GL_PROGRAM_PARAMETERS_ARB
GL_PROGRAM_PARAMETER_NV = GL_PROGRAM_PARAMETER_NV
GL_PROGRAM_RESIDENT_NV = GL_PROGRAM_RESIDENT_NV
GL_PROGRAM_STRING_ARB = GL_PROGRAM_STRING_ARB
GL_PROGRAM_STRING_NV = GL_PROGRAM_STRING_NV
GL_PROGRAM_TARGET_NV = GL_PROGRAM_TARGET_NV
GL_PROGRAM_TEMPORARIES_ARB = GL_PROGRAM_TEMPORARIES_ARB
GL_PROGRAM_TEX_INDIRECTIONS_ARB = GL_PROGRAM_TEX_INDIRECTIONS_ARB
GL_PROGRAM_TEX_INSTRUCTIONS_ARB = GL_PROGRAM_TEX_INSTRUCTIONS_ARB
GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB = GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB
GL_PROJECTION = GL_PROJECTION
GL_PROJECTION_MATRIX = GL_PROJECTION_MATRIX
GL_PROJECTION_STACK_DEPTH = GL_PROJECTION_STACK_DEPTH
GL_PROXY_COLOR_TABLE = GL_PROXY_COLOR_TABLE
GL_PROXY_COLOR_TABLE_SGI = GL_PROXY_COLOR_TABLE_SGI
GL_PROXY_HISTOGRAM = GL_PROXY_HISTOGRAM
GL_PROXY_HISTOGRAM_EXT = GL_PROXY_HISTOGRAM_EXT
GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE = GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE
GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI = GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI
GL_PROXY_POST_CONVOLUTION_COLOR_TABLE = GL_PROXY_POST_CONVOLUTION_COLOR_TABLE
GL_PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI = GL_PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI
GL_PROXY_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP = GL_PROXY_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP
GL_PROXY_TEXTURE_1D = GL_PROXY_TEXTURE_1D
GL_PROXY_TEXTURE_1D_EXT = GL_PROXY_TEXTURE_1D_EXT
GL_PROXY_TEXTURE_2D = GL_PROXY_TEXTURE_2D
GL_PROXY_TEXTURE_2D_EXT = GL_PROXY_TEXTURE_2D_EXT
GL_PROXY_TEXTURE_3D = GL_PROXY_TEXTURE_3D
GL_PROXY_TEXTURE_3D_EXT = GL_PROXY_TEXTURE_3D_EXT
GL_PROXY_TEXTURE_4D_SGIS = GL_PROXY_TEXTURE_4D_SGIS
GL_PROXY_TEXTURE_COLOR_TABLE_SGI = GL_PROXY_TEXTURE_COLOR_TABLE_SGI
GL_PROXY_TEXTURE_CUBE_MAP = GL_PROXY_TEXTURE_CUBE_MAP
GL_PROXY_TEXTURE_CUBE_MAP_ARB = GL_PROXY_TEXTURE_CUBE_MAP_ARB
GL_PROXY_TEXTURE_CUBE_MAP_EXT = GL_PROXY_TEXTURE_CUBE_MAP_EXT
GL_PROXY_TEXTURE_RECTANGLE_ARB = GL_PROXY_TEXTURE_RECTANGLE_ARB
GL_PROXY_TEXTURE_RECTANGLE_NV = GL_PROXY_TEXTURE_RECTANGLE_NV
GL_Q = GL_Q
GL_QUADRATIC_ATTENUATION = GL_QUADRATIC_ATTENUATION
GL_QUADS = GL_QUADS
GL_QUAD_ALPHA4_SGIS = GL_QUAD_ALPHA4_SGIS
GL_QUAD_ALPHA8_SGIS = GL_QUAD_ALPHA8_SGIS
GL_QUAD_INTENSITY4_SGIS = GL_QUAD_INTENSITY4_SGIS
GL_QUAD_INTENSITY8_SGIS = GL_QUAD_INTENSITY8_SGIS
GL_QUAD_LUMINANCE4_SGIS = GL_QUAD_LUMINANCE4_SGIS
GL_QUAD_LUMINANCE8_SGIS = GL_QUAD_LUMINANCE8_SGIS
GL_QUAD_MESH_SUN = GL_QUAD_MESH_SUN
GL_QUAD_STRIP = GL_QUAD_STRIP
GL_QUAD_TEXTURE_SELECT_SGIS = GL_QUAD_TEXTURE_SELECT_SGIS
GL_QUARTER_BIT_ATI = GL_QUARTER_BIT_ATI
GL_QUERY_COUNTER_BITS = GL_QUERY_COUNTER_BITS
GL_QUERY_COUNTER_BITS_ARB = GL_QUERY_COUNTER_BITS_ARB
GL_QUERY_RESULT = GL_QUERY_RESULT
GL_QUERY_RESULT_ARB = GL_QUERY_RESULT_ARB
GL_QUERY_RESULT_AVAILABLE = GL_QUERY_RESULT_AVAILABLE
GL_QUERY_RESULT_AVAILABLE_ARB = GL_QUERY_RESULT_AVAILABLE_ARB
GL_R = GL_R
GL_R1UI_C3F_V3F_SUN = GL_R1UI_C3F_V3F_SUN
GL_R1UI_C4F_N3F_V3F_SUN = GL_R1UI_C4F_N3F_V3F_SUN
GL_R1UI_C4UB_V3F_SUN = GL_R1UI_C4UB_V3F_SUN
GL_R1UI_N3F_V3F_SUN = GL_R1UI_N3F_V3F_SUN
GL_R1UI_T2F_C4F_N3F_V3F_SUN = GL_R1UI_T2F_C4F_N3F_V3F_SUN
GL_R1UI_T2F_N3F_V3F_SUN = GL_R1UI_T2F_N3F_V3F_SUN
GL_R1UI_T2F_V3F_SUN = GL_R1UI_T2F_V3F_SUN
GL_R1UI_V3F_SUN = GL_R1UI_V3F_SUN
GL_R3_G3_B2 = GL_R3_G3_B2
GL_RASTER_POSITION_UNCLIPPED_IBM = GL_RASTER_POSITION_UNCLIPPED_IBM
GL_READ_BUFFER = GL_READ_BUFFER
GL_READ_ONLY = GL_READ_ONLY
GL_READ_ONLY_ARB = GL_READ_ONLY_ARB
GL_READ_PIXEL_DATA_RANGE_LENGTH_NV = GL_READ_PIXEL_DATA_RANGE_LENGTH_NV
GL_READ_PIXEL_DATA_RANGE_NV = GL_READ_PIXEL_DATA_RANGE_NV
GL_READ_PIXEL_DATA_RANGE_POINTER_NV = GL_READ_PIXEL_DATA_RANGE_POINTER_NV
GL_READ_WRITE = GL_READ_WRITE
GL_READ_WRITE_ARB = GL_READ_WRITE_ARB
GL_RECLAIM_MEMORY_HINT_PGI = GL_RECLAIM_MEMORY_HINT_PGI
GL_RED = GL_RED
GL_REDUCE = GL_REDUCE
GL_REDUCE_EXT = GL_REDUCE_EXT
GL_RED_BIAS = GL_RED_BIAS
GL_RED_BITS = GL_RED_BITS
GL_RED_BIT_ATI = GL_RED_BIT_ATI
GL_RED_MAX_CLAMP_INGR = GL_RED_MAX_CLAMP_INGR
GL_RED_MIN_CLAMP_INGR = GL_RED_MIN_CLAMP_INGR
GL_RED_SCALE = GL_RED_SCALE
GL_REFERENCE_PLANE_EQUATION_SGIX = GL_REFERENCE_PLANE_EQUATION_SGIX
GL_REFERENCE_PLANE_SGIX = GL_REFERENCE_PLANE_SGIX
GL_REFLECTION_MAP = GL_REFLECTION_MAP
GL_REFLECTION_MAP_ARB = GL_REFLECTION_MAP_ARB
GL_REFLECTION_MAP_EXT = GL_REFLECTION_MAP_EXT
GL_REFLECTION_MAP_NV = GL_REFLECTION_MAP_NV
GL_REGISTER_COMBINERS_NV = GL_REGISTER_COMBINERS_NV
GL_REG_0_ATI = GL_REG_0_ATI
GL_REG_10_ATI = GL_REG_10_ATI
GL_REG_11_ATI = GL_REG_11_ATI
GL_REG_12_ATI = GL_REG_12_ATI
GL_REG_13_ATI = GL_REG_13_ATI
GL_REG_14_ATI = GL_REG_14_ATI
GL_REG_15_ATI = GL_REG_15_ATI
GL_REG_16_ATI = GL_REG_16_ATI
GL_REG_17_ATI = GL_REG_17_ATI
GL_REG_18_ATI = GL_REG_18_ATI
GL_REG_19_ATI = GL_REG_19_ATI
GL_REG_1_ATI = GL_REG_1_ATI
GL_REG_20_ATI = GL_REG_20_ATI
GL_REG_21_ATI = GL_REG_21_ATI
GL_REG_22_ATI = GL_REG_22_ATI
GL_REG_23_ATI = GL_REG_23_ATI
GL_REG_24_ATI = GL_REG_24_ATI
GL_REG_25_ATI = GL_REG_25_ATI
GL_REG_26_ATI = GL_REG_26_ATI
GL_REG_27_ATI = GL_REG_27_ATI
GL_REG_28_ATI = GL_REG_28_ATI
GL_REG_29_ATI = GL_REG_29_ATI
GL_REG_2_ATI = GL_REG_2_ATI
GL_REG_30_ATI = GL_REG_30_ATI
GL_REG_31_ATI = GL_REG_31_ATI
GL_REG_3_ATI = GL_REG_3_ATI
GL_REG_4_ATI = GL_REG_4_ATI
GL_REG_5_ATI = GL_REG_5_ATI
GL_REG_6_ATI = GL_REG_6_ATI
GL_REG_7_ATI = GL_REG_7_ATI
GL_REG_8_ATI = GL_REG_8_ATI
GL_REG_9_ATI = GL_REG_9_ATI
GL_RENDER = GL_RENDER
GL_RENDERBUFFER_ALPHA_SIZE_EXT = GL_RENDERBUFFER_ALPHA_SIZE_EXT
GL_RENDERBUFFER_BINDING_EXT = GL_RENDERBUFFER_BINDING_EXT
GL_RENDERBUFFER_BLUE_SIZE_EXT = GL_RENDERBUFFER_BLUE_SIZE_EXT
GL_RENDERBUFFER_DEPTH_SIZE_EXT = GL_RENDERBUFFER_DEPTH_SIZE_EXT
GL_RENDERBUFFER_EXT = GL_RENDERBUFFER_EXT
GL_RENDERBUFFER_GREEN_SIZE_EXT = GL_RENDERBUFFER_GREEN_SIZE_EXT
GL_RENDERBUFFER_HEIGHT_EXT = GL_RENDERBUFFER_HEIGHT_EXT
GL_RENDERBUFFER_INTERNAL_FORMAT_EXT = GL_RENDERBUFFER_INTERNAL_FORMAT_EXT
GL_RENDERBUFFER_RED_SIZE_EXT = GL_RENDERBUFFER_RED_SIZE_EXT
GL_RENDERBUFFER_STENCIL_SIZE_EXT = GL_RENDERBUFFER_STENCIL_SIZE_EXT
GL_RENDERBUFFER_WIDTH_EXT = GL_RENDERBUFFER_WIDTH_EXT
GL_RENDERER = GL_RENDERER
GL_RENDER_MODE = GL_RENDER_MODE
GL_REPEAT = GL_REPEAT
GL_REPLACE = GL_REPLACE
GL_REPLACEMENT_CODE_ARRAY_POINTER_SUN = GL_REPLACEMENT_CODE_ARRAY_POINTER_SUN
GL_REPLACEMENT_CODE_ARRAY_STRIDE_SUN = GL_REPLACEMENT_CODE_ARRAY_STRIDE_SUN
GL_REPLACEMENT_CODE_ARRAY_SUN = GL_REPLACEMENT_CODE_ARRAY_SUN
GL_REPLACEMENT_CODE_ARRAY_TYPE_SUN = GL_REPLACEMENT_CODE_ARRAY_TYPE_SUN
GL_REPLACEMENT_CODE_SUN = GL_REPLACEMENT_CODE_SUN
GL_REPLACE_EXT = GL_REPLACE_EXT
GL_REPLACE_MIDDLE_SUN = GL_REPLACE_MIDDLE_SUN
GL_REPLACE_OLDEST_SUN = GL_REPLACE_OLDEST_SUN
GL_REPLICATE_BORDER = GL_REPLICATE_BORDER
GL_REPLICATE_BORDER_HP = GL_REPLICATE_BORDER_HP
GL_RESAMPLE_AVERAGE_OML = GL_RESAMPLE_AVERAGE_OML
GL_RESAMPLE_DECIMATE_OML = GL_RESAMPLE_DECIMATE_OML
GL_RESAMPLE_DECIMATE_SGIX = GL_RESAMPLE_DECIMATE_SGIX
GL_RESAMPLE_REPLICATE_OML = GL_RESAMPLE_REPLICATE_OML
GL_RESAMPLE_REPLICATE_SGIX = GL_RESAMPLE_REPLICATE_SGIX
GL_RESAMPLE_ZERO_FILL_OML = GL_RESAMPLE_ZERO_FILL_OML
GL_RESAMPLE_ZERO_FILL_SGIX = GL_RESAMPLE_ZERO_FILL_SGIX
GL_RESCALE_NORMAL = GL_RESCALE_NORMAL
GL_RESCALE_NORMAL_EXT = GL_RESCALE_NORMAL_EXT
GL_RESTART_SUN = GL_RESTART_SUN
GL_RETURN = GL_RETURN
GL_RGB = GL_RGB
GL_RGB10 = GL_RGB10
GL_RGB10_A2 = GL_RGB10_A2
GL_RGB10_A2_EXT = GL_RGB10_A2_EXT
GL_RGB10_EXT = GL_RGB10_EXT
GL_RGB12 = GL_RGB12
GL_RGB12_EXT = GL_RGB12_EXT
GL_RGB16 = GL_RGB16
GL_RGB16F_ARB = GL_RGB16F_ARB
GL_RGB16_EXT = GL_RGB16_EXT
GL_RGB2_EXT = GL_RGB2_EXT
GL_RGB32F_ARB = GL_RGB32F_ARB
GL_RGB4 = GL_RGB4
GL_RGB4_EXT = GL_RGB4_EXT
GL_RGB4_S3TC = GL_RGB4_S3TC
GL_RGB5 = GL_RGB5
GL_RGB5_A1 = GL_RGB5_A1
GL_RGB5_A1_EXT = GL_RGB5_A1_EXT
GL_RGB5_EXT = GL_RGB5_EXT
GL_RGB8 = GL_RGB8
GL_RGB8_EXT = GL_RGB8_EXT
GL_RGBA = GL_RGBA
GL_RGBA12 = GL_RGBA12
GL_RGBA12_EXT = GL_RGBA12_EXT
GL_RGBA16 = GL_RGBA16
GL_RGBA16F_ARB = GL_RGBA16F_ARB
GL_RGBA16_EXT = GL_RGBA16_EXT
GL_RGBA2 = GL_RGBA2
GL_RGBA2_EXT = GL_RGBA2_EXT
GL_RGBA32F_ARB = GL_RGBA32F_ARB
GL_RGBA4 = GL_RGBA4
GL_RGBA4_EXT = GL_RGBA4_EXT
GL_RGBA4_S3TC = GL_RGBA4_S3TC
GL_RGBA8 = GL_RGBA8
GL_RGBA8_EXT = GL_RGBA8_EXT
GL_RGBA_FLOAT16_ATI = GL_RGBA_FLOAT16_ATI
GL_RGBA_FLOAT32_ATI = GL_RGBA_FLOAT32_ATI
GL_RGBA_FLOAT_MODE_ARB = GL_RGBA_FLOAT_MODE_ARB
GL_RGBA_MODE = GL_RGBA_MODE
GL_RGBA_S3TC = GL_RGBA_S3TC
GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV = GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV
GL_RGB_FLOAT16_ATI = GL_RGB_FLOAT16_ATI
GL_RGB_FLOAT32_ATI = GL_RGB_FLOAT32_ATI
GL_RGB_S3TC = GL_RGB_S3TC
GL_RGB_SCALE = GL_RGB_SCALE
GL_RGB_SCALE_ARB = GL_RGB_SCALE_ARB
GL_RGB_SCALE_EXT = GL_RGB_SCALE_EXT
GL_RIGHT = GL_RIGHT
GL_S = GL_S
GL_SAMPLER_1D = GL_SAMPLER_1D
GL_SAMPLER_1D_ARB = GL_SAMPLER_1D_ARB
GL_SAMPLER_1D_SHADOW = GL_SAMPLER_1D_SHADOW
GL_SAMPLER_1D_SHADOW_ARB = GL_SAMPLER_1D_SHADOW_ARB
GL_SAMPLER_2D = GL_SAMPLER_2D
GL_SAMPLER_2D_ARB = GL_SAMPLER_2D_ARB
GL_SAMPLER_2D_RECT_ARB = GL_SAMPLER_2D_RECT_ARB
GL_SAMPLER_2D_RECT_SHADOW_ARB = GL_SAMPLER_2D_RECT_SHADOW_ARB
GL_SAMPLER_2D_SHADOW = GL_SAMPLER_2D_SHADOW
GL_SAMPLER_2D_SHADOW_ARB = GL_SAMPLER_2D_SHADOW_ARB
GL_SAMPLER_3D = GL_SAMPLER_3D
GL_SAMPLER_3D_ARB = GL_SAMPLER_3D_ARB
GL_SAMPLER_CUBE = GL_SAMPLER_CUBE
GL_SAMPLER_CUBE_ARB = GL_SAMPLER_CUBE_ARB
GL_SAMPLES = GL_SAMPLES
GL_SAMPLES_3DFX = GL_SAMPLES_3DFX
GL_SAMPLES_ARB = GL_SAMPLES_ARB
GL_SAMPLES_EXT = GL_SAMPLES_EXT
GL_SAMPLES_PASSED = GL_SAMPLES_PASSED
GL_SAMPLES_PASSED_ARB = GL_SAMPLES_PASSED_ARB
GL_SAMPLES_SGIS = GL_SAMPLES_SGIS
GL_SAMPLE_ALPHA_TO_COVERAGE = GL_SAMPLE_ALPHA_TO_COVERAGE
GL_SAMPLE_ALPHA_TO_COVERAGE_ARB = GL_SAMPLE_ALPHA_TO_COVERAGE_ARB
GL_SAMPLE_ALPHA_TO_MASK_EXT = GL_SAMPLE_ALPHA_TO_MASK_EXT
GL_SAMPLE_ALPHA_TO_MASK_SGIS = GL_SAMPLE_ALPHA_TO_MASK_SGIS
GL_SAMPLE_ALPHA_TO_ONE = GL_SAMPLE_ALPHA_TO_ONE
GL_SAMPLE_ALPHA_TO_ONE_ARB = GL_SAMPLE_ALPHA_TO_ONE_ARB
GL_SAMPLE_ALPHA_TO_ONE_EXT = GL_SAMPLE_ALPHA_TO_ONE_EXT
GL_SAMPLE_ALPHA_TO_ONE_SGIS = GL_SAMPLE_ALPHA_TO_ONE_SGIS
GL_SAMPLE_BUFFERS = GL_SAMPLE_BUFFERS
GL_SAMPLE_BUFFERS_3DFX = GL_SAMPLE_BUFFERS_3DFX
GL_SAMPLE_BUFFERS_ARB = GL_SAMPLE_BUFFERS_ARB
GL_SAMPLE_BUFFERS_EXT = GL_SAMPLE_BUFFERS_EXT
GL_SAMPLE_BUFFERS_SGIS = GL_SAMPLE_BUFFERS_SGIS
GL_SAMPLE_COVERAGE = GL_SAMPLE_COVERAGE
GL_SAMPLE_COVERAGE_ARB = GL_SAMPLE_COVERAGE_ARB
GL_SAMPLE_COVERAGE_INVERT = GL_SAMPLE_COVERAGE_INVERT
GL_SAMPLE_COVERAGE_INVERT_ARB = GL_SAMPLE_COVERAGE_INVERT_ARB
GL_SAMPLE_COVERAGE_VALUE = GL_SAMPLE_COVERAGE_VALUE
GL_SAMPLE_COVERAGE_VALUE_ARB = GL_SAMPLE_COVERAGE_VALUE_ARB
GL_SAMPLE_MASK_EXT = GL_SAMPLE_MASK_EXT
GL_SAMPLE_MASK_INVERT_EXT = GL_SAMPLE_MASK_INVERT_EXT
GL_SAMPLE_MASK_INVERT_SGIS = GL_SAMPLE_MASK_INVERT_SGIS
GL_SAMPLE_MASK_SGIS = GL_SAMPLE_MASK_SGIS
GL_SAMPLE_MASK_VALUE_EXT = GL_SAMPLE_MASK_VALUE_EXT
GL_SAMPLE_MASK_VALUE_SGIS = GL_SAMPLE_MASK_VALUE_SGIS
GL_SAMPLE_PATTERN_EXT = GL_SAMPLE_PATTERN_EXT
GL_SAMPLE_PATTERN_SGIS = GL_SAMPLE_PATTERN_SGIS
GL_SATURATE_BIT_ATI = GL_SATURATE_BIT_ATI
GL_SCALAR_EXT = GL_SCALAR_EXT
GL_SCALEBIAS_HINT_SGIX = GL_SCALEBIAS_HINT_SGIX
GL_SCALE_BY_FOUR_NV = GL_SCALE_BY_FOUR_NV
GL_SCALE_BY_ONE_HALF_NV = GL_SCALE_BY_ONE_HALF_NV
GL_SCALE_BY_TWO_NV = GL_SCALE_BY_TWO_NV
GL_SCISSOR_BIT = GL_SCISSOR_BIT
GL_SCISSOR_BOX = GL_SCISSOR_BOX
GL_SCISSOR_TEST = GL_SCISSOR_TEST
GL_SCREEN_COORDINATES_REND = GL_SCREEN_COORDINATES_REND
GL_SECONDARY_COLOR_ARRAY = GL_SECONDARY_COLOR_ARRAY
GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING = GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING
GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB = GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB
GL_SECONDARY_COLOR_ARRAY_EXT = GL_SECONDARY_COLOR_ARRAY_EXT
GL_SECONDARY_COLOR_ARRAY_LIST_IBM = GL_SECONDARY_COLOR_ARRAY_LIST_IBM
GL_SECONDARY_COLOR_ARRAY_LIST_STRIDE_IBM = GL_SECONDARY_COLOR_ARRAY_LIST_STRIDE_IBM
GL_SECONDARY_COLOR_ARRAY_POINTER = GL_SECONDARY_COLOR_ARRAY_POINTER
GL_SECONDARY_COLOR_ARRAY_POINTER_EXT = GL_SECONDARY_COLOR_ARRAY_POINTER_EXT
GL_SECONDARY_COLOR_ARRAY_SIZE = GL_SECONDARY_COLOR_ARRAY_SIZE
GL_SECONDARY_COLOR_ARRAY_SIZE_EXT = GL_SECONDARY_COLOR_ARRAY_SIZE_EXT
GL_SECONDARY_COLOR_ARRAY_STRIDE = GL_SECONDARY_COLOR_ARRAY_STRIDE
GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT = GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT
GL_SECONDARY_COLOR_ARRAY_TYPE = GL_SECONDARY_COLOR_ARRAY_TYPE
GL_SECONDARY_COLOR_ARRAY_TYPE_EXT = GL_SECONDARY_COLOR_ARRAY_TYPE_EXT
GL_SECONDARY_COLOR_NV = GL_SECONDARY_COLOR_NV
GL_SECONDARY_INTERPOLATOR_ATI = GL_SECONDARY_INTERPOLATOR_ATI
GL_SELECT = GL_SELECT
GL_SELECTION_BUFFER_POINTER = GL_SELECTION_BUFFER_POINTER
GL_SELECTION_BUFFER_SIZE = GL_SELECTION_BUFFER_SIZE
GL_SEPARABLE_2D = GL_SEPARABLE_2D
GL_SEPARABLE_2D_EXT = GL_SEPARABLE_2D_EXT
GL_SEPARATE_SPECULAR_COLOR = GL_SEPARATE_SPECULAR_COLOR
GL_SEPARATE_SPECULAR_COLOR_EXT = GL_SEPARATE_SPECULAR_COLOR_EXT
GL_SET = GL_SET
GL_SHADER_CONSISTENT_NV = GL_SHADER_CONSISTENT_NV
GL_SHADER_OBJECT_ARB = GL_SHADER_OBJECT_ARB
GL_SHADER_OPERATION_NV = GL_SHADER_OPERATION_NV
GL_SHADER_SOURCE_LENGTH = GL_SHADER_SOURCE_LENGTH
GL_SHADER_TYPE = GL_SHADER_TYPE
GL_SHADE_MODEL = GL_SHADE_MODEL
GL_SHADING_LANGUAGE_VERSION = GL_SHADING_LANGUAGE_VERSION
GL_SHADING_LANGUAGE_VERSION_ARB = GL_SHADING_LANGUAGE_VERSION_ARB
GL_SHADOW_AMBIENT_SGIX = GL_SHADOW_AMBIENT_SGIX
GL_SHADOW_ATTENUATION_EXT = GL_SHADOW_ATTENUATION_EXT
GL_SHARED_TEXTURE_PALETTE_EXT = GL_SHARED_TEXTURE_PALETTE_EXT
GL_SHARPEN_TEXTURE_FUNC_POINTS_SGIS = GL_SHARPEN_TEXTURE_FUNC_POINTS_SGIS
GL_SHININESS = GL_SHININESS
GL_SHORT = GL_SHORT
GL_SIGNED_ALPHA8_NV = GL_SIGNED_ALPHA8_NV
GL_SIGNED_ALPHA_NV = GL_SIGNED_ALPHA_NV
GL_SIGNED_HILO16_NV = GL_SIGNED_HILO16_NV
GL_SIGNED_HILO8_NV = GL_SIGNED_HILO8_NV
GL_SIGNED_HILO_NV = GL_SIGNED_HILO_NV
GL_SIGNED_IDENTITY_NV = GL_SIGNED_IDENTITY_NV
GL_SIGNED_INTENSITY8_NV = GL_SIGNED_INTENSITY8_NV
GL_SIGNED_INTENSITY_NV = GL_SIGNED_INTENSITY_NV
GL_SIGNED_LUMINANCE8_ALPHA8_NV = GL_SIGNED_LUMINANCE8_ALPHA8_NV
GL_SIGNED_LUMINANCE8_NV = GL_SIGNED_LUMINANCE8_NV
GL_SIGNED_LUMINANCE_ALPHA_NV = GL_SIGNED_LUMINANCE_ALPHA_NV
GL_SIGNED_LUMINANCE_NV = GL_SIGNED_LUMINANCE_NV
GL_SIGNED_NEGATE_NV = GL_SIGNED_NEGATE_NV
GL_SIGNED_RGB8_NV = GL_SIGNED_RGB8_NV
GL_SIGNED_RGB8_UNSIGNED_ALPHA8_NV = GL_SIGNED_RGB8_UNSIGNED_ALPHA8_NV
GL_SIGNED_RGBA8_NV = GL_SIGNED_RGBA8_NV
GL_SIGNED_RGBA_NV = GL_SIGNED_RGBA_NV
GL_SIGNED_RGB_NV = GL_SIGNED_RGB_NV
GL_SIGNED_RGB_UNSIGNED_ALPHA_NV = GL_SIGNED_RGB_UNSIGNED_ALPHA_NV
GL_SINGLE_COLOR = GL_SINGLE_COLOR
GL_SINGLE_COLOR_EXT = GL_SINGLE_COLOR_EXT
GL_SLICE_ACCUM_SUN = GL_SLICE_ACCUM_SUN
GL_SLUMINANCE = GL_SLUMINANCE
GL_SLUMINANCE8 = GL_SLUMINANCE8
GL_SLUMINANCE8_ALPHA8 = GL_SLUMINANCE8_ALPHA8
GL_SLUMINANCE_ALPHA = GL_SLUMINANCE_ALPHA
GL_SMOOTH = GL_SMOOTH
GL_SMOOTH_LINE_WIDTH_GRANULARITY = GL_SMOOTH_LINE_WIDTH_GRANULARITY
GL_SMOOTH_LINE_WIDTH_RANGE = GL_SMOOTH_LINE_WIDTH_RANGE
GL_SMOOTH_POINT_SIZE_GRANULARITY = GL_SMOOTH_POINT_SIZE_GRANULARITY
GL_SMOOTH_POINT_SIZE_RANGE = GL_SMOOTH_POINT_SIZE_RANGE
GL_SOURCE0_ALPHA = GL_SOURCE0_ALPHA
GL_SOURCE0_ALPHA_ARB = GL_SOURCE0_ALPHA_ARB
GL_SOURCE0_ALPHA_EXT = GL_SOURCE0_ALPHA_EXT
GL_SOURCE0_RGB = GL_SOURCE0_RGB
GL_SOURCE0_RGB_ARB = GL_SOURCE0_RGB_ARB
GL_SOURCE0_RGB_EXT = GL_SOURCE0_RGB_EXT
GL_SOURCE1_ALPHA = GL_SOURCE1_ALPHA
GL_SOURCE1_ALPHA_ARB = GL_SOURCE1_ALPHA_ARB
GL_SOURCE1_ALPHA_EXT = GL_SOURCE1_ALPHA_EXT
GL_SOURCE1_RGB = GL_SOURCE1_RGB
GL_SOURCE1_RGB_ARB = GL_SOURCE1_RGB_ARB
GL_SOURCE1_RGB_EXT = GL_SOURCE1_RGB_EXT
GL_SOURCE2_ALPHA = GL_SOURCE2_ALPHA
GL_SOURCE2_ALPHA_ARB = GL_SOURCE2_ALPHA_ARB
GL_SOURCE2_ALPHA_EXT = GL_SOURCE2_ALPHA_EXT
GL_SOURCE2_RGB = GL_SOURCE2_RGB
GL_SOURCE2_RGB_ARB = GL_SOURCE2_RGB_ARB
GL_SOURCE2_RGB_EXT = GL_SOURCE2_RGB_EXT
GL_SOURCE3_ALPHA_NV = GL_SOURCE3_ALPHA_NV
GL_SOURCE3_RGB_NV = GL_SOURCE3_RGB_NV
GL_SPARE0_NV = GL_SPARE0_NV
GL_SPARE0_PLUS_SECONDARY_COLOR_NV = GL_SPARE0_PLUS_SECONDARY_COLOR_NV
GL_SPARE1_NV = GL_SPARE1_NV
GL_SPECULAR = GL_SPECULAR
GL_SPHERE_MAP = GL_SPHERE_MAP
GL_SPOT_CUTOFF = GL_SPOT_CUTOFF
GL_SPOT_DIRECTION = GL_SPOT_DIRECTION
GL_SPOT_EXPONENT = GL_SPOT_EXPONENT
GL_SPRITE_AXIAL_SGIX = GL_SPRITE_AXIAL_SGIX
GL_SPRITE_AXIS_SGIX = GL_SPRITE_AXIS_SGIX
GL_SPRITE_EYE_ALIGNED_SGIX = GL_SPRITE_EYE_ALIGNED_SGIX
GL_SPRITE_MODE_SGIX = GL_SPRITE_MODE_SGIX
GL_SPRITE_OBJECT_ALIGNED_SGIX = GL_SPRITE_OBJECT_ALIGNED_SGIX
GL_SPRITE_SGIX = GL_SPRITE_SGIX
GL_SPRITE_TRANSLATION_SGIX = GL_SPRITE_TRANSLATION_SGIX
GL_SRC0_ALPHA = GL_SOURCE0_ALPHA
GL_SRC0_RGB = GL_SOURCE0_RGB
GL_SRC1_ALPHA = GL_SOURCE1_ALPHA
GL_SRC1_RGB = GL_SOURCE1_RGB
GL_SRC2_ALPHA = GL_SOURCE2_ALPHA
GL_SRC2_RGB = GL_SOURCE2_RGB
GL_SRC_ALPHA = GL_SRC_ALPHA
GL_SRC_ALPHA_SATURATE = GL_SRC_ALPHA_SATURATE
GL_SRC_COLOR = GL_SRC_COLOR
GL_SRGB = GL_SRGB
GL_SRGB8 = GL_SRGB8
GL_SRGB8_ALPHA8 = GL_SRGB8_ALPHA8
GL_SRGB_ALPHA = GL_SRGB_ALPHA
GL_STACK_OVERFLOW = GL_STACK_OVERFLOW
GL_STACK_UNDERFLOW = GL_STACK_UNDERFLOW
GL_STATIC_ATI = GL_STATIC_ATI
GL_STATIC_COPY = GL_STATIC_COPY
GL_STATIC_COPY_ARB = GL_STATIC_COPY_ARB
GL_STATIC_DRAW = GL_STATIC_DRAW
GL_STATIC_DRAW_ARB = GL_STATIC_DRAW_ARB
GL_STATIC_READ = GL_STATIC_READ
GL_STATIC_READ_ARB = GL_STATIC_READ_ARB
GL_STENCIL = GL_STENCIL
GL_STENCIL_ATTACHMENT_EXT = GL_STENCIL_ATTACHMENT_EXT
GL_STENCIL_BACK_FAIL = GL_STENCIL_BACK_FAIL
GL_STENCIL_BACK_FAIL_ATI = GL_STENCIL_BACK_FAIL_ATI
GL_STENCIL_BACK_FUNC = GL_STENCIL_BACK_FUNC
GL_STENCIL_BACK_FUNC_ATI = GL_STENCIL_BACK_FUNC_ATI
GL_STENCIL_BACK_PASS_DEPTH_FAIL = GL_STENCIL_BACK_PASS_DEPTH_FAIL
GL_STENCIL_BACK_PASS_DEPTH_FAIL_ATI = GL_STENCIL_BACK_PASS_DEPTH_FAIL_ATI
GL_STENCIL_BACK_PASS_DEPTH_PASS = GL_STENCIL_BACK_PASS_DEPTH_PASS
GL_STENCIL_BACK_PASS_DEPTH_PASS_ATI = GL_STENCIL_BACK_PASS_DEPTH_PASS_ATI
GL_STENCIL_BACK_REF = GL_STENCIL_BACK_REF
GL_STENCIL_BACK_VALUE_MASK = GL_STENCIL_BACK_VALUE_MASK
GL_STENCIL_BACK_WRITEMASK = GL_STENCIL_BACK_WRITEMASK
GL_STENCIL_BITS = GL_STENCIL_BITS
GL_STENCIL_BUFFER_BIT = GL_STENCIL_BUFFER_BIT
GL_STENCIL_CLEAR_VALUE = GL_STENCIL_CLEAR_VALUE
GL_STENCIL_FAIL = GL_STENCIL_FAIL
GL_STENCIL_FUNC = GL_STENCIL_FUNC
GL_STENCIL_INDEX = GL_STENCIL_INDEX
GL_STENCIL_INDEX16_EXT = GL_STENCIL_INDEX16_EXT
GL_STENCIL_INDEX1_EXT = GL_STENCIL_INDEX1_EXT
GL_STENCIL_INDEX4_EXT = GL_STENCIL_INDEX4_EXT
GL_STENCIL_INDEX8_EXT = GL_STENCIL_INDEX8_EXT
GL_STENCIL_PASS_DEPTH_FAIL = GL_STENCIL_PASS_DEPTH_FAIL
GL_STENCIL_PASS_DEPTH_PASS = GL_STENCIL_PASS_DEPTH_PASS
GL_STENCIL_REF = GL_STENCIL_REF
GL_STENCIL_TEST = GL_STENCIL_TEST
GL_STENCIL_TEST_TWO_SIDE_EXT = GL_STENCIL_TEST_TWO_SIDE_EXT
GL_STENCIL_VALUE_MASK = GL_STENCIL_VALUE_MASK
GL_STENCIL_WRITEMASK = GL_STENCIL_WRITEMASK
GL_STEREO = GL_STEREO
GL_STORAGE_CACHED_APPLE = GL_STORAGE_CACHED_APPLE
GL_STORAGE_SHARED_APPLE = GL_STORAGE_SHARED_APPLE
GL_STREAM_COPY = GL_STREAM_COPY
GL_STREAM_COPY_ARB = GL_STREAM_COPY_ARB
GL_STREAM_DRAW = GL_STREAM_DRAW
GL_STREAM_DRAW_ARB = GL_STREAM_DRAW_ARB
GL_STREAM_READ = GL_STREAM_READ
GL_STREAM_READ_ARB = GL_STREAM_READ_ARB
GL_STRICT_DEPTHFUNC_HINT_PGI = GL_STRICT_DEPTHFUNC_HINT_PGI
GL_STRICT_LIGHTING_HINT_PGI = GL_STRICT_LIGHTING_HINT_PGI
GL_STRICT_SCISSOR_HINT_PGI = GL_STRICT_SCISSOR_HINT_PGI
GL_SUBPIXEL_BITS = GL_SUBPIXEL_BITS
GL_SUBTRACT = GL_SUBTRACT
GL_SUBTRACT_ARB = GL_SUBTRACT_ARB
GL_SUB_ATI = GL_SUB_ATI
GL_SWIZZLE_STQ_ATI = GL_SWIZZLE_STQ_ATI
GL_SWIZZLE_STQ_DQ_ATI = GL_SWIZZLE_STQ_DQ_ATI
GL_SWIZZLE_STRQ_ATI = GL_SWIZZLE_STRQ_ATI
GL_SWIZZLE_STRQ_DQ_ATI = GL_SWIZZLE_STRQ_DQ_ATI
GL_SWIZZLE_STR_ATI = GL_SWIZZLE_STR_ATI
GL_SWIZZLE_STR_DR_ATI = GL_SWIZZLE_STR_DR_ATI
GL_T = GL_T
GL_T2F_C3F_V3F = GL_T2F_C3F_V3F
GL_T2F_C4F_N3F_V3F = GL_T2F_C4F_N3F_V3F
GL_T2F_C4UB_V3F = GL_T2F_C4UB_V3F
GL_T2F_IUI_N3F_V2F_EXT = GL_T2F_IUI_N3F_V2F_EXT
GL_T2F_IUI_N3F_V3F_EXT = GL_T2F_IUI_N3F_V3F_EXT
GL_T2F_IUI_V2F_EXT = GL_T2F_IUI_V2F_EXT
GL_T2F_IUI_V3F_EXT = GL_T2F_IUI_V3F_EXT
GL_T2F_N3F_V3F = GL_T2F_N3F_V3F
GL_T2F_V3F = GL_T2F_V3F
GL_T4F_C4F_N3F_V4F = GL_T4F_C4F_N3F_V4F
GL_T4F_V4F = GL_T4F_V4F
GL_TABLE_TOO_LARGE = GL_TABLE_TOO_LARGE
GL_TABLE_TOO_LARGE_EXT = GL_TABLE_TOO_LARGE_EXT
GL_TANGENT_ARRAY_EXT = GL_TANGENT_ARRAY_EXT
GL_TANGENT_ARRAY_POINTER_EXT = GL_TANGENT_ARRAY_POINTER_EXT
GL_TANGENT_ARRAY_STRIDE_EXT = GL_TANGENT_ARRAY_STRIDE_EXT
GL_TANGENT_ARRAY_TYPE_EXT = GL_TANGENT_ARRAY_TYPE_EXT
GL_TEXCOORD1_BIT_PGI = GL_TEXCOORD1_BIT_PGI
GL_TEXCOORD2_BIT_PGI = GL_TEXCOORD2_BIT_PGI
GL_TEXCOORD3_BIT_PGI = GL_TEXCOORD3_BIT_PGI
GL_TEXCOORD4_BIT_PGI = GL_TEXCOORD4_BIT_PGI
GL_TEXTURE = GL_TEXTURE
GL_TEXTURE0 = GL_TEXTURE0
GL_TEXTURE0_ARB = GL_TEXTURE0_ARB
GL_TEXTURE1 = GL_TEXTURE1
GL_TEXTURE10 = GL_TEXTURE10
GL_TEXTURE10_ARB = GL_TEXTURE10_ARB
GL_TEXTURE11 = GL_TEXTURE11
GL_TEXTURE11_ARB = GL_TEXTURE11_ARB
GL_TEXTURE12 = GL_TEXTURE12
GL_TEXTURE12_ARB = GL_TEXTURE12_ARB
GL_TEXTURE13 = GL_TEXTURE13
GL_TEXTURE13_ARB = GL_TEXTURE13_ARB
GL_TEXTURE14 = GL_TEXTURE14
GL_TEXTURE14_ARB = GL_TEXTURE14_ARB
GL_TEXTURE15 = GL_TEXTURE15
GL_TEXTURE15_ARB = GL_TEXTURE15_ARB
GL_TEXTURE16 = GL_TEXTURE16
GL_TEXTURE16_ARB = GL_TEXTURE16_ARB
GL_TEXTURE17 = GL_TEXTURE17
GL_TEXTURE17_ARB = GL_TEXTURE17_ARB
GL_TEXTURE18 = GL_TEXTURE18
GL_TEXTURE18_ARB = GL_TEXTURE18_ARB
GL_TEXTURE19 = GL_TEXTURE19
GL_TEXTURE19_ARB = GL_TEXTURE19_ARB
GL_TEXTURE1_ARB = GL_TEXTURE1_ARB
GL_TEXTURE2 = GL_TEXTURE2
GL_TEXTURE20 = GL_TEXTURE20
GL_TEXTURE20_ARB = GL_TEXTURE20_ARB
GL_TEXTURE21 = GL_TEXTURE21
GL_TEXTURE21_ARB = GL_TEXTURE21_ARB
GL_TEXTURE22 = GL_TEXTURE22
GL_TEXTURE22_ARB = GL_TEXTURE22_ARB
GL_TEXTURE23 = GL_TEXTURE23
GL_TEXTURE23_ARB = GL_TEXTURE23_ARB
GL_TEXTURE24 = GL_TEXTURE24
GL_TEXTURE24_ARB = GL_TEXTURE24_ARB
GL_TEXTURE25 = GL_TEXTURE25
GL_TEXTURE25_ARB = GL_TEXTURE25_ARB
GL_TEXTURE26 = GL_TEXTURE26
GL_TEXTURE26_ARB = GL_TEXTURE26_ARB
GL_TEXTURE27 = GL_TEXTURE27
GL_TEXTURE27_ARB = GL_TEXTURE27_ARB
GL_TEXTURE28 = GL_TEXTURE28
GL_TEXTURE28_ARB = GL_TEXTURE28_ARB
GL_TEXTURE29 = GL_TEXTURE29
GL_TEXTURE29_ARB = GL_TEXTURE29_ARB
GL_TEXTURE2_ARB = GL_TEXTURE2_ARB
GL_TEXTURE3 = GL_TEXTURE3
GL_TEXTURE30 = GL_TEXTURE30
GL_TEXTURE30_ARB = GL_TEXTURE30_ARB
GL_TEXTURE31 = GL_TEXTURE31
GL_TEXTURE31_ARB = GL_TEXTURE31_ARB
GL_TEXTURE3_ARB = GL_TEXTURE3_ARB
GL_TEXTURE4 = GL_TEXTURE4
GL_TEXTURE4_ARB = GL_TEXTURE4_ARB
GL_TEXTURE5 = GL_TEXTURE5
GL_TEXTURE5_ARB = GL_TEXTURE5_ARB
GL_TEXTURE6 = GL_TEXTURE6
GL_TEXTURE6_ARB = GL_TEXTURE6_ARB
GL_TEXTURE7 = GL_TEXTURE7
GL_TEXTURE7_ARB = GL_TEXTURE7_ARB
GL_TEXTURE8 = GL_TEXTURE8
GL_TEXTURE8_ARB = GL_TEXTURE8_ARB
GL_TEXTURE9 = GL_TEXTURE9
GL_TEXTURE9_ARB = GL_TEXTURE9_ARB
GL_TEXTURE_1D = GL_TEXTURE_1D
GL_TEXTURE_1D_BINDING_EXT = GL_TEXTURE_1D_BINDING_EXT
GL_TEXTURE_2D = GL_TEXTURE_2D
GL_TEXTURE_2D_BINDING_EXT = GL_TEXTURE_2D_BINDING_EXT
GL_TEXTURE_3D = GL_TEXTURE_3D
GL_TEXTURE_3D_BINDING_EXT = GL_TEXTURE_3D_BINDING_EXT
GL_TEXTURE_3D_EXT = GL_TEXTURE_3D_EXT
GL_TEXTURE_4DSIZE_SGIS = GL_TEXTURE_4DSIZE_SGIS
GL_TEXTURE_4D_BINDING_SGIS = GL_TEXTURE_4D_BINDING_SGIS
GL_TEXTURE_4D_SGIS = GL_TEXTURE_4D_SGIS
GL_TEXTURE_ALPHA_SIZE = GL_TEXTURE_ALPHA_SIZE
GL_TEXTURE_ALPHA_SIZE_EXT = GL_TEXTURE_ALPHA_SIZE_EXT
GL_TEXTURE_ALPHA_TYPE_ARB = GL_TEXTURE_ALPHA_TYPE_ARB
GL_TEXTURE_APPLICATION_MODE_EXT = GL_TEXTURE_APPLICATION_MODE_EXT
GL_TEXTURE_BASE_LEVEL = GL_TEXTURE_BASE_LEVEL
GL_TEXTURE_BASE_LEVEL_SGIS = GL_TEXTURE_BASE_LEVEL_SGIS
GL_TEXTURE_BINDING_1D = GL_TEXTURE_BINDING_1D
GL_TEXTURE_BINDING_2D = GL_TEXTURE_BINDING_2D
GL_TEXTURE_BINDING_3D = GL_TEXTURE_BINDING_3D
GL_TEXTURE_BINDING_CUBE_MAP = GL_TEXTURE_BINDING_CUBE_MAP
GL_TEXTURE_BINDING_CUBE_MAP_ARB = GL_TEXTURE_BINDING_CUBE_MAP_ARB
GL_TEXTURE_BINDING_CUBE_MAP_EXT = GL_TEXTURE_BINDING_CUBE_MAP_EXT
GL_TEXTURE_BINDING_RECTANGLE_ARB = GL_TEXTURE_BINDING_RECTANGLE_ARB
GL_TEXTURE_BINDING_RECTANGLE_NV = GL_TEXTURE_BINDING_RECTANGLE_NV
GL_TEXTURE_BIT = GL_TEXTURE_BIT
GL_TEXTURE_BLUE_SIZE = GL_TEXTURE_BLUE_SIZE
GL_TEXTURE_BLUE_SIZE_EXT = GL_TEXTURE_BLUE_SIZE_EXT
GL_TEXTURE_BLUE_TYPE_ARB = GL_TEXTURE_BLUE_TYPE_ARB
GL_TEXTURE_BORDER = GL_TEXTURE_BORDER
GL_TEXTURE_BORDER_COLOR = GL_TEXTURE_BORDER_COLOR
GL_TEXTURE_BORDER_VALUES_NV = GL_TEXTURE_BORDER_VALUES_NV
GL_TEXTURE_CLIPMAP_CENTER_SGIX = GL_TEXTURE_CLIPMAP_CENTER_SGIX
GL_TEXTURE_CLIPMAP_DEPTH_SGIX = GL_TEXTURE_CLIPMAP_DEPTH_SGIX
GL_TEXTURE_CLIPMAP_FRAME_SGIX = GL_TEXTURE_CLIPMAP_FRAME_SGIX
GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX = GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX
GL_TEXTURE_CLIPMAP_OFFSET_SGIX = GL_TEXTURE_CLIPMAP_OFFSET_SGIX
GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX = GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX
GL_TEXTURE_COLOR_TABLE_SGI = GL_TEXTURE_COLOR_TABLE_SGI
GL_TEXTURE_COLOR_WRITEMASK_SGIS = GL_TEXTURE_COLOR_WRITEMASK_SGIS
GL_TEXTURE_COMPARE_FAIL_VALUE_ARB = GL_TEXTURE_COMPARE_FAIL_VALUE_ARB
GL_TEXTURE_COMPARE_FUNC = GL_TEXTURE_COMPARE_FUNC
GL_TEXTURE_COMPARE_FUNC_ARB = GL_TEXTURE_COMPARE_FUNC_ARB
GL_TEXTURE_COMPARE_MODE = GL_TEXTURE_COMPARE_MODE
GL_TEXTURE_COMPARE_MODE_ARB = GL_TEXTURE_COMPARE_MODE_ARB
GL_TEXTURE_COMPARE_OPERATOR_SGIX = GL_TEXTURE_COMPARE_OPERATOR_SGIX
GL_TEXTURE_COMPARE_SGIX = GL_TEXTURE_COMPARE_SGIX
GL_TEXTURE_COMPONENTS = GL_TEXTURE_INTERNAL_FORMAT
GL_TEXTURE_COMPRESSED = GL_TEXTURE_COMPRESSED
GL_TEXTURE_COMPRESSED_ARB = GL_TEXTURE_COMPRESSED_ARB
GL_TEXTURE_COMPRESSED_IMAGE_SIZE = GL_TEXTURE_COMPRESSED_IMAGE_SIZE
GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB = GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB
GL_TEXTURE_COMPRESSION_HINT = GL_TEXTURE_COMPRESSION_HINT
GL_TEXTURE_COMPRESSION_HINT_ARB = GL_TEXTURE_COMPRESSION_HINT_ARB
GL_TEXTURE_CONSTANT_DATA_SUNX = GL_TEXTURE_CONSTANT_DATA_SUNX
GL_TEXTURE_COORD_ARRAY = GL_TEXTURE_COORD_ARRAY
GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING = GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING
GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB = GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB
GL_TEXTURE_COORD_ARRAY_COUNT_EXT = GL_TEXTURE_COORD_ARRAY_COUNT_EXT
GL_TEXTURE_COORD_ARRAY_EXT = GL_TEXTURE_COORD_ARRAY_EXT
GL_TEXTURE_COORD_ARRAY_LIST_IBM = GL_TEXTURE_COORD_ARRAY_LIST_IBM
GL_TEXTURE_COORD_ARRAY_LIST_STRIDE_IBM = GL_TEXTURE_COORD_ARRAY_LIST_STRIDE_IBM
GL_TEXTURE_COORD_ARRAY_PARALLEL_POINTERS_INTEL = GL_TEXTURE_COORD_ARRAY_PARALLEL_POINTERS_INTEL
GL_TEXTURE_COORD_ARRAY_POINTER = GL_TEXTURE_COORD_ARRAY_POINTER
GL_TEXTURE_COORD_ARRAY_POINTER_EXT = GL_TEXTURE_COORD_ARRAY_POINTER_EXT
GL_TEXTURE_COORD_ARRAY_SIZE = GL_TEXTURE_COORD_ARRAY_SIZE
GL_TEXTURE_COORD_ARRAY_SIZE_EXT = GL_TEXTURE_COORD_ARRAY_SIZE_EXT
GL_TEXTURE_COORD_ARRAY_STRIDE = GL_TEXTURE_COORD_ARRAY_STRIDE
GL_TEXTURE_COORD_ARRAY_STRIDE_EXT = GL_TEXTURE_COORD_ARRAY_STRIDE_EXT
GL_TEXTURE_COORD_ARRAY_TYPE = GL_TEXTURE_COORD_ARRAY_TYPE
GL_TEXTURE_COORD_ARRAY_TYPE_EXT = GL_TEXTURE_COORD_ARRAY_TYPE_EXT
GL_TEXTURE_CUBE_MAP = GL_TEXTURE_CUBE_MAP
GL_TEXTURE_CUBE_MAP_ARB = GL_TEXTURE_CUBE_MAP_ARB
GL_TEXTURE_CUBE_MAP_EXT = GL_TEXTURE_CUBE_MAP_EXT
GL_TEXTURE_CUBE_MAP_NEGATIVE_X = GL_TEXTURE_CUBE_MAP_NEGATIVE_X
GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB = GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB
GL_TEXTURE_CUBE_MAP_NEGATIVE_X_EXT = GL_TEXTURE_CUBE_MAP_NEGATIVE_X_EXT
GL_TEXTURE_CUBE_MAP_NEGATIVE_Y = GL_TEXTURE_CUBE_MAP_NEGATIVE_Y
GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB = GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB
GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_EXT = GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_EXT
GL_TEXTURE_CUBE_MAP_NEGATIVE_Z = GL_TEXTURE_CUBE_MAP_NEGATIVE_Z
GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB = GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB
GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_EXT = GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_EXT
GL_TEXTURE_CUBE_MAP_POSITIVE_X = GL_TEXTURE_CUBE_MAP_POSITIVE_X
GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB = GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB
GL_TEXTURE_CUBE_MAP_POSITIVE_X_EXT = GL_TEXTURE_CUBE_MAP_POSITIVE_X_EXT
GL_TEXTURE_CUBE_MAP_POSITIVE_Y = GL_TEXTURE_CUBE_MAP_POSITIVE_Y
GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB = GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB
GL_TEXTURE_CUBE_MAP_POSITIVE_Y_EXT = GL_TEXTURE_CUBE_MAP_POSITIVE_Y_EXT
GL_TEXTURE_CUBE_MAP_POSITIVE_Z = GL_TEXTURE_CUBE_MAP_POSITIVE_Z
GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB = GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB
GL_TEXTURE_CUBE_MAP_POSITIVE_Z_EXT = GL_TEXTURE_CUBE_MAP_POSITIVE_Z_EXT
GL_TEXTURE_DEFORMATION_BIT_SGIX = GL_TEXTURE_DEFORMATION_BIT_SGIX
GL_TEXTURE_DEFORMATION_SGIX = GL_TEXTURE_DEFORMATION_SGIX
GL_TEXTURE_DEPTH = GL_TEXTURE_DEPTH
GL_TEXTURE_DEPTH_EXT = GL_TEXTURE_DEPTH_EXT
GL_TEXTURE_DEPTH_SIZE = GL_TEXTURE_DEPTH_SIZE
GL_TEXTURE_DEPTH_SIZE_ARB = GL_TEXTURE_DEPTH_SIZE_ARB
GL_TEXTURE_DEPTH_TYPE_ARB = GL_TEXTURE_DEPTH_TYPE_ARB
GL_TEXTURE_DS_SIZE_NV = GL_TEXTURE_DS_SIZE_NV
GL_TEXTURE_DT_SIZE_NV = GL_TEXTURE_DT_SIZE_NV
GL_TEXTURE_ENV = GL_TEXTURE_ENV
GL_TEXTURE_ENV_BIAS_SGIX = GL_TEXTURE_ENV_BIAS_SGIX
GL_TEXTURE_ENV_COLOR = GL_TEXTURE_ENV_COLOR
GL_TEXTURE_ENV_MODE = GL_TEXTURE_ENV_MODE
GL_TEXTURE_FILTER4_SIZE_SGIS = GL_TEXTURE_FILTER4_SIZE_SGIS
GL_TEXTURE_FILTER_CONTROL = GL_TEXTURE_FILTER_CONTROL
GL_TEXTURE_FILTER_CONTROL_EXT = GL_TEXTURE_FILTER_CONTROL_EXT
GL_TEXTURE_FLOAT_COMPONENTS_NV = GL_TEXTURE_FLOAT_COMPONENTS_NV
GL_TEXTURE_GEN_MODE = GL_TEXTURE_GEN_MODE
GL_TEXTURE_GEN_Q = GL_TEXTURE_GEN_Q
GL_TEXTURE_GEN_R = GL_TEXTURE_GEN_R
GL_TEXTURE_GEN_S = GL_TEXTURE_GEN_S
GL_TEXTURE_GEN_T = GL_TEXTURE_GEN_T
GL_TEXTURE_GEQUAL_R_SGIX = GL_TEXTURE_GEQUAL_R_SGIX
GL_TEXTURE_GREEN_SIZE = GL_TEXTURE_GREEN_SIZE
GL_TEXTURE_GREEN_SIZE_EXT = GL_TEXTURE_GREEN_SIZE_EXT
GL_TEXTURE_GREEN_TYPE_ARB = GL_TEXTURE_GREEN_TYPE_ARB
GL_TEXTURE_HEIGHT = GL_TEXTURE_HEIGHT
GL_TEXTURE_HI_SIZE_NV = GL_TEXTURE_HI_SIZE_NV
GL_TEXTURE_INDEX_SIZE_EXT = GL_TEXTURE_INDEX_SIZE_EXT
GL_TEXTURE_INTENSITY_SIZE = GL_TEXTURE_INTENSITY_SIZE
GL_TEXTURE_INTENSITY_SIZE_EXT = GL_TEXTURE_INTENSITY_SIZE_EXT
GL_TEXTURE_INTENSITY_TYPE_ARB = GL_TEXTURE_INTENSITY_TYPE_ARB
GL_TEXTURE_INTERNAL_FORMAT = GL_TEXTURE_INTERNAL_FORMAT
GL_TEXTURE_LEQUAL_R_SGIX = GL_TEXTURE_LEQUAL_R_SGIX
GL_TEXTURE_LIGHTING_MODE_HP = GL_TEXTURE_LIGHTING_MODE_HP
GL_TEXTURE_LIGHT_EXT = GL_TEXTURE_LIGHT_EXT
GL_TEXTURE_LOD_BIAS = GL_TEXTURE_LOD_BIAS
GL_TEXTURE_LOD_BIAS_EXT = GL_TEXTURE_LOD_BIAS_EXT
GL_TEXTURE_LOD_BIAS_R_SGIX = GL_TEXTURE_LOD_BIAS_R_SGIX
GL_TEXTURE_LOD_BIAS_S_SGIX = GL_TEXTURE_LOD_BIAS_S_SGIX
GL_TEXTURE_LOD_BIAS_T_SGIX = GL_TEXTURE_LOD_BIAS_T_SGIX
GL_TEXTURE_LO_SIZE_NV = GL_TEXTURE_LO_SIZE_NV
GL_TEXTURE_LUMINANCE_SIZE = GL_TEXTURE_LUMINANCE_SIZE
GL_TEXTURE_LUMINANCE_SIZE_EXT = GL_TEXTURE_LUMINANCE_SIZE_EXT
GL_TEXTURE_LUMINANCE_TYPE_ARB = GL_TEXTURE_LUMINANCE_TYPE_ARB
GL_TEXTURE_MAG_FILTER = GL_TEXTURE_MAG_FILTER
GL_TEXTURE_MAG_SIZE_NV = GL_TEXTURE_MAG_SIZE_NV
GL_TEXTURE_MATERIAL_FACE_EXT = GL_TEXTURE_MATERIAL_FACE_EXT
GL_TEXTURE_MATERIAL_PARAMETER_EXT = GL_TEXTURE_MATERIAL_PARAMETER_EXT
GL_TEXTURE_MATRIX = GL_TEXTURE_MATRIX
GL_TEXTURE_MAX_ANISOTROPY_EXT = GL_TEXTURE_MAX_ANISOTROPY_EXT
GL_TEXTURE_MAX_CLAMP_R_SGIX = GL_TEXTURE_MAX_CLAMP_R_SGIX
GL_TEXTURE_MAX_CLAMP_S_SGIX = GL_TEXTURE_MAX_CLAMP_S_SGIX
GL_TEXTURE_MAX_CLAMP_T_SGIX = GL_TEXTURE_MAX_CLAMP_T_SGIX
GL_TEXTURE_MAX_LEVEL = GL_TEXTURE_MAX_LEVEL
GL_TEXTURE_MAX_LEVEL_SGIS = GL_TEXTURE_MAX_LEVEL_SGIS
GL_TEXTURE_MAX_LOD = GL_TEXTURE_MAX_LOD
GL_TEXTURE_MAX_LOD_SGIS = GL_TEXTURE_MAX_LOD_SGIS
GL_TEXTURE_MIN_FILTER = GL_TEXTURE_MIN_FILTER
GL_TEXTURE_MIN_LOD = GL_TEXTURE_MIN_LOD
GL_TEXTURE_MIN_LOD_SGIS = GL_TEXTURE_MIN_LOD_SGIS
GL_TEXTURE_MULTI_BUFFER_HINT_SGIX = GL_TEXTURE_MULTI_BUFFER_HINT_SGIX
GL_TEXTURE_NORMAL_EXT = GL_TEXTURE_NORMAL_EXT
GL_TEXTURE_POST_SPECULAR_HP = GL_TEXTURE_POST_SPECULAR_HP
GL_TEXTURE_PRE_SPECULAR_HP = GL_TEXTURE_PRE_SPECULAR_HP
GL_TEXTURE_PRIORITY = GL_TEXTURE_PRIORITY
GL_TEXTURE_PRIORITY_EXT = GL_TEXTURE_PRIORITY_EXT
GL_TEXTURE_RECTANGLE_ARB = GL_TEXTURE_RECTANGLE_ARB
GL_TEXTURE_RECTANGLE_NV = GL_TEXTURE_RECTANGLE_NV
GL_TEXTURE_RED_SIZE = GL_TEXTURE_RED_SIZE
GL_TEXTURE_RED_SIZE_EXT = GL_TEXTURE_RED_SIZE_EXT
GL_TEXTURE_RED_TYPE_ARB = GL_TEXTURE_RED_TYPE_ARB
GL_TEXTURE_RESIDENT = GL_TEXTURE_RESIDENT
GL_TEXTURE_RESIDENT_EXT = GL_TEXTURE_RESIDENT_EXT
GL_TEXTURE_SHADER_NV = GL_TEXTURE_SHADER_NV
GL_TEXTURE_STACK_DEPTH = GL_TEXTURE_STACK_DEPTH
GL_TEXTURE_TOO_LARGE_EXT = GL_TEXTURE_TOO_LARGE_EXT
GL_TEXTURE_UNSIGNED_REMAP_MODE_NV = GL_TEXTURE_UNSIGNED_REMAP_MODE_NV
GL_TEXTURE_WIDTH = GL_TEXTURE_WIDTH
GL_TEXTURE_WRAP_Q_SGIS = GL_TEXTURE_WRAP_Q_SGIS
GL_TEXTURE_WRAP_R = GL_TEXTURE_WRAP_R
GL_TEXTURE_WRAP_R_EXT = GL_TEXTURE_WRAP_R_EXT
GL_TEXTURE_WRAP_S = GL_TEXTURE_WRAP_S
GL_TEXTURE_WRAP_T = GL_TEXTURE_WRAP_T
GL_TEXT_FRAGMENT_SHADER_ATI = GL_TEXT_FRAGMENT_SHADER_ATI
GL_TRACK_MATRIX_NV = GL_TRACK_MATRIX_NV
GL_TRACK_MATRIX_TRANSFORM_NV = GL_TRACK_MATRIX_TRANSFORM_NV
GL_TRANSFORM_BIT = GL_TRANSFORM_BIT
GL_TRANSFORM_HINT_APPLE = GL_TRANSFORM_HINT_APPLE
GL_TRANSPOSE_COLOR_MATRIX = GL_TRANSPOSE_COLOR_MATRIX
GL_TRANSPOSE_COLOR_MATRIX_ARB = GL_TRANSPOSE_COLOR_MATRIX_ARB
GL_TRANSPOSE_CURRENT_MATRIX_ARB = GL_TRANSPOSE_CURRENT_MATRIX_ARB
GL_TRANSPOSE_MODELVIEW_MATRIX = GL_TRANSPOSE_MODELVIEW_MATRIX
GL_TRANSPOSE_MODELVIEW_MATRIX_ARB = GL_TRANSPOSE_MODELVIEW_MATRIX_ARB
GL_TRANSPOSE_NV = GL_TRANSPOSE_NV
GL_TRANSPOSE_PROJECTION_MATRIX = GL_TRANSPOSE_PROJECTION_MATRIX
GL_TRANSPOSE_PROJECTION_MATRIX_ARB = GL_TRANSPOSE_PROJECTION_MATRIX_ARB
GL_TRANSPOSE_TEXTURE_MATRIX = GL_TRANSPOSE_TEXTURE_MATRIX
GL_TRANSPOSE_TEXTURE_MATRIX_ARB = GL_TRANSPOSE_TEXTURE_MATRIX_ARB
GL_TRIANGLES = GL_TRIANGLES
GL_TRIANGLE_FAN = GL_TRIANGLE_FAN
GL_TRIANGLE_LIST_SUN = GL_TRIANGLE_LIST_SUN
GL_TRIANGLE_MESH_SUN = GL_TRIANGLE_MESH_SUN
GL_TRIANGLE_STRIP = GL_TRIANGLE_STRIP
GL_TRUE = GL_TRUE
GL_TYPE_RGBA_FLOAT_ATI = GL_TYPE_RGBA_FLOAT_ATI
GL_UNPACK_ALIGNMENT = GL_UNPACK_ALIGNMENT
GL_UNPACK_CLIENT_STORAGE_APPLE = GL_UNPACK_CLIENT_STORAGE_APPLE
GL_UNPACK_CMYK_HINT_EXT = GL_UNPACK_CMYK_HINT_EXT
GL_UNPACK_CONSTANT_DATA_SUNX = GL_UNPACK_CONSTANT_DATA_SUNX
GL_UNPACK_IMAGE_DEPTH_SGIS = GL_UNPACK_IMAGE_DEPTH_SGIS
GL_UNPACK_IMAGE_HEIGHT = GL_UNPACK_IMAGE_HEIGHT
GL_UNPACK_IMAGE_HEIGHT_EXT = GL_UNPACK_IMAGE_HEIGHT_EXT
GL_UNPACK_LSB_FIRST = GL_UNPACK_LSB_FIRST
GL_UNPACK_RESAMPLE_OML = GL_UNPACK_RESAMPLE_OML
GL_UNPACK_RESAMPLE_SGIX = GL_UNPACK_RESAMPLE_SGIX
GL_UNPACK_ROW_LENGTH = GL_UNPACK_ROW_LENGTH
GL_UNPACK_SKIP_IMAGES = GL_UNPACK_SKIP_IMAGES
GL_UNPACK_SKIP_IMAGES_EXT = GL_UNPACK_SKIP_IMAGES_EXT
GL_UNPACK_SKIP_PIXELS = GL_UNPACK_SKIP_PIXELS
GL_UNPACK_SKIP_ROWS = GL_UNPACK_SKIP_ROWS
GL_UNPACK_SKIP_VOLUMES_SGIS = GL_UNPACK_SKIP_VOLUMES_SGIS
GL_UNPACK_SUBSAMPLE_RATE_SGIX = GL_UNPACK_SUBSAMPLE_RATE_SGIX
GL_UNPACK_SWAP_BYTES = GL_UNPACK_SWAP_BYTES
GL_UNSIGNED_BYTE = GL_UNSIGNED_BYTE
GL_UNSIGNED_BYTE_2_3_3_REV = GL_UNSIGNED_BYTE_2_3_3_REV
GL_UNSIGNED_BYTE_3_3_2 = GL_UNSIGNED_BYTE_3_3_2
GL_UNSIGNED_BYTE_3_3_2_EXT = GL_UNSIGNED_BYTE_3_3_2_EXT
GL_UNSIGNED_IDENTITY_NV = GL_UNSIGNED_IDENTITY_NV
GL_UNSIGNED_INT = GL_UNSIGNED_INT
GL_UNSIGNED_INT_10_10_10_2 = GL_UNSIGNED_INT_10_10_10_2
GL_UNSIGNED_INT_10_10_10_2_EXT = GL_UNSIGNED_INT_10_10_10_2_EXT
GL_UNSIGNED_INT_24_8_NV = GL_UNSIGNED_INT_24_8_NV
GL_UNSIGNED_INT_2_10_10_10_REV = GL_UNSIGNED_INT_2_10_10_10_REV
GL_UNSIGNED_INT_8_8_8_8 = GL_UNSIGNED_INT_8_8_8_8
GL_UNSIGNED_INT_8_8_8_8_EXT = GL_UNSIGNED_INT_8_8_8_8_EXT
GL_UNSIGNED_INT_8_8_8_8_REV = GL_UNSIGNED_INT_8_8_8_8_REV
GL_UNSIGNED_INT_8_8_S8_S8_REV_NV = GL_UNSIGNED_INT_8_8_S8_S8_REV_NV
GL_UNSIGNED_INT_S8_S8_8_8_NV = GL_UNSIGNED_INT_S8_S8_8_8_NV
GL_UNSIGNED_INVERT_NV = GL_UNSIGNED_INVERT_NV
GL_UNSIGNED_NORMALIZED_ARB = GL_UNSIGNED_NORMALIZED_ARB
GL_UNSIGNED_SHORT = GL_UNSIGNED_SHORT
GL_UNSIGNED_SHORT_1_5_5_5_REV = GL_UNSIGNED_SHORT_1_5_5_5_REV
GL_UNSIGNED_SHORT_4_4_4_4 = GL_UNSIGNED_SHORT_4_4_4_4
GL_UNSIGNED_SHORT_4_4_4_4_EXT = GL_UNSIGNED_SHORT_4_4_4_4_EXT
GL_UNSIGNED_SHORT_4_4_4_4_REV = GL_UNSIGNED_SHORT_4_4_4_4_REV
GL_UNSIGNED_SHORT_5_5_5_1 = GL_UNSIGNED_SHORT_5_5_5_1
GL_UNSIGNED_SHORT_5_5_5_1_EXT = GL_UNSIGNED_SHORT_5_5_5_1_EXT
GL_UNSIGNED_SHORT_5_6_5 = GL_UNSIGNED_SHORT_5_6_5
GL_UNSIGNED_SHORT_5_6_5_REV = GL_UNSIGNED_SHORT_5_6_5_REV
GL_UNSIGNED_SHORT_8_8_APPLE = GL_UNSIGNED_SHORT_8_8_APPLE
GL_UNSIGNED_SHORT_8_8_MESA = GL_UNSIGNED_SHORT_8_8_MESA
GL_UNSIGNED_SHORT_8_8_REV_APPLE = GL_UNSIGNED_SHORT_8_8_REV_APPLE
GL_UNSIGNED_SHORT_8_8_REV_MESA = GL_UNSIGNED_SHORT_8_8_REV_MESA
GL_UPPER_LEFT = GL_UPPER_LEFT
GL_V2F = GL_V2F
GL_V3F = GL_V3F
GL_VALIDATE_STATUS = GL_VALIDATE_STATUS
GL_VARIABLE_A_NV = GL_VARIABLE_A_NV
GL_VARIABLE_B_NV = GL_VARIABLE_B_NV
GL_VARIABLE_C_NV = GL_VARIABLE_C_NV
GL_VARIABLE_D_NV = GL_VARIABLE_D_NV
GL_VARIABLE_E_NV = GL_VARIABLE_E_NV
GL_VARIABLE_F_NV = GL_VARIABLE_F_NV
GL_VARIABLE_G_NV = GL_VARIABLE_G_NV
GL_VARIANT_ARRAY_EXT = GL_VARIANT_ARRAY_EXT
GL_VARIANT_ARRAY_POINTER_EXT = GL_VARIANT_ARRAY_POINTER_EXT
GL_VARIANT_ARRAY_STRIDE_EXT = GL_VARIANT_ARRAY_STRIDE_EXT
GL_VARIANT_ARRAY_TYPE_EXT = GL_VARIANT_ARRAY_TYPE_EXT
GL_VARIANT_DATATYPE_EXT = GL_VARIANT_DATATYPE_EXT
GL_VARIANT_EXT = GL_VARIANT_EXT
GL_VARIANT_VALUE_EXT = GL_VARIANT_VALUE_EXT
GL_VECTOR_EXT = GL_VECTOR_EXT
GL_VENDOR = GL_VENDOR
GL_VERSION = GL_VERSION
GL_VERSION_1_1 = GL_VERSION_1_1
GL_VERSION_1_2 = GL_VERSION_1_2
GL_VERSION_1_3 = GL_VERSION_1_3
GL_VERSION_1_4 = GL_VERSION_1_4
GL_VERSION_1_5 = GL_VERSION_1_5
GL_VERSION_2_0 = GL_VERSION_2_0
GL_VERTEX23_BIT_PGI = GL_VERTEX23_BIT_PGI
GL_VERTEX4_BIT_PGI = GL_VERTEX4_BIT_PGI
GL_VERTEX_ARRAY = GL_VERTEX_ARRAY
GL_VERTEX_ARRAY_BINDING_APPLE = GL_VERTEX_ARRAY_BINDING_APPLE
GL_VERTEX_ARRAY_BUFFER_BINDING = GL_VERTEX_ARRAY_BUFFER_BINDING
GL_VERTEX_ARRAY_BUFFER_BINDING_ARB = GL_VERTEX_ARRAY_BUFFER_BINDING_ARB
GL_VERTEX_ARRAY_COUNT_EXT = GL_VERTEX_ARRAY_COUNT_EXT
GL_VERTEX_ARRAY_EXT = GL_VERTEX_ARRAY_EXT
GL_VERTEX_ARRAY_LIST_IBM = GL_VERTEX_ARRAY_LIST_IBM
GL_VERTEX_ARRAY_LIST_STRIDE_IBM = GL_VERTEX_ARRAY_LIST_STRIDE_IBM
GL_VERTEX_ARRAY_PARALLEL_POINTERS_INTEL = GL_VERTEX_ARRAY_PARALLEL_POINTERS_INTEL
GL_VERTEX_ARRAY_POINTER = GL_VERTEX_ARRAY_POINTER
GL_VERTEX_ARRAY_POINTER_EXT = GL_VERTEX_ARRAY_POINTER_EXT
GL_VERTEX_ARRAY_RANGE_APPLE = GL_VERTEX_ARRAY_RANGE_APPLE
GL_VERTEX_ARRAY_RANGE_LENGTH_APPLE = GL_VERTEX_ARRAY_RANGE_LENGTH_APPLE
GL_VERTEX_ARRAY_RANGE_LENGTH_NV = GL_VERTEX_ARRAY_RANGE_LENGTH_NV
GL_VERTEX_ARRAY_RANGE_NV = GL_VERTEX_ARRAY_RANGE_NV
GL_VERTEX_ARRAY_RANGE_POINTER_APPLE = GL_VERTEX_ARRAY_RANGE_POINTER_APPLE
GL_VERTEX_ARRAY_RANGE_POINTER_NV = GL_VERTEX_ARRAY_RANGE_POINTER_NV
GL_VERTEX_ARRAY_RANGE_VALID_NV = GL_VERTEX_ARRAY_RANGE_VALID_NV
GL_VERTEX_ARRAY_RANGE_WITHOUT_FLUSH_NV = GL_VERTEX_ARRAY_RANGE_WITHOUT_FLUSH_NV
GL_VERTEX_ARRAY_SIZE = GL_VERTEX_ARRAY_SIZE
GL_VERTEX_ARRAY_SIZE_EXT = GL_VERTEX_ARRAY_SIZE_EXT
GL_VERTEX_ARRAY_STORAGE_HINT_APPLE = GL_VERTEX_ARRAY_STORAGE_HINT_APPLE
GL_VERTEX_ARRAY_STRIDE = GL_VERTEX_ARRAY_STRIDE
GL_VERTEX_ARRAY_STRIDE_EXT = GL_VERTEX_ARRAY_STRIDE_EXT
GL_VERTEX_ARRAY_TYPE = GL_VERTEX_ARRAY_TYPE
GL_VERTEX_ARRAY_TYPE_EXT = GL_VERTEX_ARRAY_TYPE_EXT
GL_VERTEX_ATTRIB_ARRAY0_NV = GL_VERTEX_ATTRIB_ARRAY0_NV
GL_VERTEX_ATTRIB_ARRAY10_NV = GL_VERTEX_ATTRIB_ARRAY10_NV
GL_VERTEX_ATTRIB_ARRAY11_NV = GL_VERTEX_ATTRIB_ARRAY11_NV
GL_VERTEX_ATTRIB_ARRAY12_NV = GL_VERTEX_ATTRIB_ARRAY12_NV
GL_VERTEX_ATTRIB_ARRAY13_NV = GL_VERTEX_ATTRIB_ARRAY13_NV
GL_VERTEX_ATTRIB_ARRAY14_NV = GL_VERTEX_ATTRIB_ARRAY14_NV
GL_VERTEX_ATTRIB_ARRAY15_NV = GL_VERTEX_ATTRIB_ARRAY15_NV
GL_VERTEX_ATTRIB_ARRAY1_NV = GL_VERTEX_ATTRIB_ARRAY1_NV
GL_VERTEX_ATTRIB_ARRAY2_NV = GL_VERTEX_ATTRIB_ARRAY2_NV
GL_VERTEX_ATTRIB_ARRAY3_NV = GL_VERTEX_ATTRIB_ARRAY3_NV
GL_VERTEX_ATTRIB_ARRAY4_NV = GL_VERTEX_ATTRIB_ARRAY4_NV
GL_VERTEX_ATTRIB_ARRAY5_NV = GL_VERTEX_ATTRIB_ARRAY5_NV
GL_VERTEX_ATTRIB_ARRAY6_NV = GL_VERTEX_ATTRIB_ARRAY6_NV
GL_VERTEX_ATTRIB_ARRAY7_NV = GL_VERTEX_ATTRIB_ARRAY7_NV
GL_VERTEX_ATTRIB_ARRAY8_NV = GL_VERTEX_ATTRIB_ARRAY8_NV
GL_VERTEX_ATTRIB_ARRAY9_NV = GL_VERTEX_ATTRIB_ARRAY9_NV
GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING
GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB = GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB
GL_VERTEX_ATTRIB_ARRAY_ENABLED = GL_VERTEX_ATTRIB_ARRAY_ENABLED
GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB = GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB
GL_VERTEX_ATTRIB_ARRAY_NORMALIZED = GL_VERTEX_ATTRIB_ARRAY_NORMALIZED
GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB = GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB
GL_VERTEX_ATTRIB_ARRAY_POINTER = GL_VERTEX_ATTRIB_ARRAY_POINTER
GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB = GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB
GL_VERTEX_ATTRIB_ARRAY_SIZE = GL_VERTEX_ATTRIB_ARRAY_SIZE
GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB = GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB
GL_VERTEX_ATTRIB_ARRAY_STRIDE = GL_VERTEX_ATTRIB_ARRAY_STRIDE
GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB = GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB
GL_VERTEX_ATTRIB_ARRAY_TYPE = GL_VERTEX_ATTRIB_ARRAY_TYPE
GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB = GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB
GL_VERTEX_BLEND_ARB = GL_VERTEX_BLEND_ARB
GL_VERTEX_CONSISTENT_HINT_PGI = GL_VERTEX_CONSISTENT_HINT_PGI
GL_VERTEX_DATA_HINT_PGI = GL_VERTEX_DATA_HINT_PGI
GL_VERTEX_PRECLIP_HINT_SGIX = GL_VERTEX_PRECLIP_HINT_SGIX
GL_VERTEX_PRECLIP_SGIX = GL_VERTEX_PRECLIP_SGIX
GL_VERTEX_PROGRAM_ARB = GL_VERTEX_PROGRAM_ARB
GL_VERTEX_PROGRAM_BINDING_NV = GL_VERTEX_PROGRAM_BINDING_NV
GL_VERTEX_PROGRAM_NV = GL_VERTEX_PROGRAM_NV
GL_VERTEX_PROGRAM_POINT_SIZE = GL_VERTEX_PROGRAM_POINT_SIZE
GL_VERTEX_PROGRAM_POINT_SIZE_ARB = GL_VERTEX_PROGRAM_POINT_SIZE_ARB
GL_VERTEX_PROGRAM_POINT_SIZE_NV = GL_VERTEX_PROGRAM_POINT_SIZE_NV
GL_VERTEX_PROGRAM_TWO_SIDE = GL_VERTEX_PROGRAM_TWO_SIDE
GL_VERTEX_PROGRAM_TWO_SIDE_ARB = GL_VERTEX_PROGRAM_TWO_SIDE_ARB
GL_VERTEX_PROGRAM_TWO_SIDE_NV = GL_VERTEX_PROGRAM_TWO_SIDE_NV
GL_VERTEX_SHADER = GL_VERTEX_SHADER
GL_VERTEX_SHADER_ARB = GL_VERTEX_SHADER_ARB
GL_VERTEX_SHADER_BINDING_EXT = GL_VERTEX_SHADER_BINDING_EXT
GL_VERTEX_SHADER_EXT = GL_VERTEX_SHADER_EXT
GL_VERTEX_SHADER_INSTRUCTIONS_EXT = GL_VERTEX_SHADER_INSTRUCTIONS_EXT
GL_VERTEX_SHADER_INVARIANTS_EXT = GL_VERTEX_SHADER_INVARIANTS_EXT
GL_VERTEX_SHADER_LOCALS_EXT = GL_VERTEX_SHADER_LOCALS_EXT
GL_VERTEX_SHADER_LOCAL_CONSTANTS_EXT = GL_VERTEX_SHADER_LOCAL_CONSTANTS_EXT
GL_VERTEX_SHADER_OPTIMIZED_EXT = GL_VERTEX_SHADER_OPTIMIZED_EXT
GL_VERTEX_SHADER_VARIANTS_EXT = GL_VERTEX_SHADER_VARIANTS_EXT
GL_VERTEX_SOURCE_ATI = GL_VERTEX_SOURCE_ATI
GL_VERTEX_STATE_PROGRAM_NV = GL_VERTEX_STATE_PROGRAM_NV
GL_VERTEX_STREAM0_ATI = GL_VERTEX_STREAM0_ATI
GL_VERTEX_STREAM1_ATI = GL_VERTEX_STREAM1_ATI
GL_VERTEX_STREAM2_ATI = GL_VERTEX_STREAM2_ATI
GL_VERTEX_STREAM3_ATI = GL_VERTEX_STREAM3_ATI
GL_VERTEX_STREAM4_ATI = GL_VERTEX_STREAM4_ATI
GL_VERTEX_STREAM5_ATI = GL_VERTEX_STREAM5_ATI
GL_VERTEX_STREAM6_ATI = GL_VERTEX_STREAM6_ATI
GL_VERTEX_STREAM7_ATI = GL_VERTEX_STREAM7_ATI
GL_VERTEX_WEIGHTING_EXT = GL_VERTEX_WEIGHTING_EXT
GL_VERTEX_WEIGHT_ARRAY_EXT = GL_VERTEX_WEIGHT_ARRAY_EXT
GL_VERTEX_WEIGHT_ARRAY_POINTER_EXT = GL_VERTEX_WEIGHT_ARRAY_POINTER_EXT
GL_VERTEX_WEIGHT_ARRAY_SIZE_EXT = GL_VERTEX_WEIGHT_ARRAY_SIZE_EXT
GL_VERTEX_WEIGHT_ARRAY_STRIDE_EXT = GL_VERTEX_WEIGHT_ARRAY_STRIDE_EXT
GL_VERTEX_WEIGHT_ARRAY_TYPE_EXT = GL_VERTEX_WEIGHT_ARRAY_TYPE_EXT
GL_VIBRANCE_BIAS_NV = GL_VIBRANCE_BIAS_NV
GL_VIBRANCE_SCALE_NV = GL_VIBRANCE_SCALE_NV
GL_VIEWPORT = GL_VIEWPORT
GL_VIEWPORT_BIT = GL_VIEWPORT_BIT
GL_WEIGHT_ARRAY_ARB = GL_WEIGHT_ARRAY_ARB
GL_WEIGHT_ARRAY_BUFFER_BINDING = GL_WEIGHT_ARRAY_BUFFER_BINDING
GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB = GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB
GL_WEIGHT_ARRAY_POINTER_ARB = GL_WEIGHT_ARRAY_POINTER_ARB
GL_WEIGHT_ARRAY_SIZE_ARB = GL_WEIGHT_ARRAY_SIZE_ARB
GL_WEIGHT_ARRAY_STRIDE_ARB = GL_WEIGHT_ARRAY_STRIDE_ARB
GL_WEIGHT_ARRAY_TYPE_ARB = GL_WEIGHT_ARRAY_TYPE_ARB
GL_WEIGHT_SUM_UNITY_ARB = GL_WEIGHT_SUM_UNITY_ARB
GL_WIDE_LINE_HINT_PGI = GL_WIDE_LINE_HINT_PGI
GL_WRAP_BORDER_SUN = GL_WRAP_BORDER_SUN
GL_WRITE_ONLY = GL_WRITE_ONLY
GL_WRITE_ONLY_ARB = GL_WRITE_ONLY_ARB
GL_WRITE_PIXEL_DATA_RANGE_LENGTH_NV = GL_WRITE_PIXEL_DATA_RANGE_LENGTH_NV
GL_WRITE_PIXEL_DATA_RANGE_NV = GL_WRITE_PIXEL_DATA_RANGE_NV
GL_WRITE_PIXEL_DATA_RANGE_POINTER_NV = GL_WRITE_PIXEL_DATA_RANGE_POINTER_NV
GL_W_EXT = GL_W_EXT
GL_XOR = GL_XOR
GL_X_EXT = GL_X_EXT
GL_YCBCR_422_APPLE = GL_YCBCR_422_APPLE
GL_YCBCR_MESA = GL_YCBCR_MESA
GL_YCRCBA_SGIX = GL_YCRCBA_SGIX
GL_YCRCB_422_SGIX = GL_YCRCB_422_SGIX
GL_YCRCB_444_SGIX = GL_YCRCB_444_SGIX
GL_YCRCB_SGIX = GL_YCRCB_SGIX
GL_Y_EXT = GL_Y_EXT
GL_ZERO = GL_ZERO
GL_ZERO_EXT = GL_ZERO_EXT
GL_ZOOM_X = GL_ZOOM_X
GL_ZOOM_Y = GL_ZOOM_Y
GL_Z_EXT = GL_Z_EXT
GLvoid = None
__file__ = '/build/buildd/pyopengl-3.0.0~b3/OpenGL/GL/__init__.py'
__name__ = 'OpenGL.GL'
__path__ = ['/build/buildd/pyopengl-3.0.0~b3/OpenGL/GL']
name = 'glUniform4iv'