OpenGL.tests.test_glutwindow
index
/var/pylive/OpenGL-ctypes/OpenGL/tests/test_glutwindow.py

Test simple functions (i.e. no pointers involved)

 
Modules
       
OpenGL.GL.APPLE
OpenGL.GL.ARB
OpenGL.GL.ATI
OpenGL.GL.DFX
OpenGL.GLU.EXT
OpenGL.GL.GREMEDY
OpenGL.GL.HP
OpenGL.GL.IBM
OpenGL.GL.INGR
OpenGL.GL.INTEL
OpenGL.GL.MESA
OpenGL.GL.NV
OpenGL.GL.OES
OpenGL.GL.OML
OpenGL.GL.PGI
OpenGL.GL.REND
OpenGL.GL.S3
OpenGL.GL.SGI
OpenGL.GL.SGIS
OpenGL.GL.SGIX
OpenGL.GL.SUN
OpenGL.GL.SUNX
OpenGL.GL.VERSION
OpenGL.GL.WIN
OpenGL.arrays
OpenGL.constant
OpenGL.constants
OpenGL.contextdata
OpenGL.converters
ctypes
OpenGL.error
OpenGL.GL.exceptional
OpenGL.extensions
OpenGL.GL.feedback
OpenGL.GLUT.fonts
OpenGL.GLUT.freeglut
OpenGL.GL.glget
OpenGL.GLU.glunurbs
OpenGL.GLU.glustruct
OpenGL.GL.images
OpenGL.raw.GL.ARB.imaging
OpenGL.logs
os
OpenGL.platform
OpenGL.GL.pointers
OpenGL.GLU.projection
OpenGL.GLU.quadrics
OpenGL.GL.selection
OpenGL.raw.GLUT
OpenGL.GLUT.special
sys
OpenGL.GLU.tess
time
traceback
OpenGL.wrapper

 
Functions
       
CurrentContextIsValid = glXGetCurrentContext(...)
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
display()
drawText(value, x, y, windowHeight, windowWidth, step=18)
Draw the given text at given 2D position in window
glAccum(...)
glAccum( GLenum(op), GLfloat(value) ) -> None
glActiveTexture(...)
glActiveTexture( GLenum(texture) ) -> None
glAlphaFunc(...)
glAlphaFunc( GLenum(func), GLclampf(ref) ) -> None
glAreTexturesResident( n,textures,residences )
pyConverters: n=None, textures=<OpenGL.converters.CallFuncPyConverter object>, residences=None
cConverters: n=None, textures=<OpenGL.converters.getPyArgsName object>, residences=None
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: glAreTexturesResident( GLsizei(n), arrays.GLuintArray(textures), POINTER(GLboolean)(residences) ) -> GLboolean
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>
cConverters: width=None, height=None, xorig=None, yorig=None, xmove=None, ymove=None, bitmap=<OpenGL.converters.getPyArgsName object>
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>
cConverters: plane=None, equation=<OpenGL.converters.getPyArgsName object>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
returnValues: <OpenGL.converters.returnPyArgument object>
Wrapping Operation: glColorPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glColorPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object>
cConverters: size=
arraySizeOfFirst(pyArgs, index, baseOperation)
Return the array size of the first argument
, type=GL_BYTE, stride=0, pointer=<OpenGL.converters.getPyArgsName object>
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>
returnValues: <OpenGL.converters.returnPyArgument object>
Wrapping Operation: glColorPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glColorPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object>
cConverters: size=
arraySizeOfFirst(pyArgs, index, baseOperation)
Return the array size of the first argument
, type=GL_DOUBLE, stride=0, pointer=<OpenGL.converters.getPyArgsName object>
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>
returnValues: <OpenGL.converters.returnPyArgument object>
Wrapping Operation: glColorPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glColorPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object>
cConverters: size=
arraySizeOfFirst(pyArgs, index, baseOperation)
Return the array size of the first argument
, type=GL_FLOAT, stride=0, pointer=<OpenGL.converters.getPyArgsName object>
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>
returnValues: <OpenGL.converters.returnPyArgument object>
Wrapping Operation: glColorPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glColorPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object>
cConverters: size=
arraySizeOfFirst(pyArgs, index, baseOperation)
Return the array size of the first argument
, type=GL_INT, stride=0, pointer=<OpenGL.converters.getPyArgsName object>
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>
returnValues: <OpenGL.converters.returnPyArgument object>
Wrapping Operation: glColorPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glColorPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object>
cConverters: size=
arraySizeOfFirst(pyArgs, index, baseOperation)
Return the array size of the first argument
, type=GL_SHORT, stride=0, pointer=<OpenGL.converters.getPyArgsName object>
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>
returnValues: <OpenGL.converters.returnPyArgument object>
Wrapping Operation: glColorPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glColorPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object>
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>
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>
returnValues: <OpenGL.converters.returnPyArgument object>
Wrapping Operation: glColorPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glColorPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object>
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>
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>
returnValues: <OpenGL.converters.returnPyArgument object>
Wrapping Operation: glColorPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glColorPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object>
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>
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>
returnValues: <OpenGL.converters.returnPyArgument object>
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>
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>
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>
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>, 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>, 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>, 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>, 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>, 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>, 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>
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>
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>
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>
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>
cConverters: mode=None, count=<OpenGL.arrays.arrayhelpers.AsArrayTypedSize object>, 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>
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>
cConverters: mode=None, count=<OpenGL.arrays.arrayhelpers.AsArrayTypedSize object>, 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>
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>
cConverters: mode=None, count=<OpenGL.arrays.arrayhelpers.AsArrayTypedSize object>, 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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
returnValues: <OpenGL.converters.returnPyArgument object>
Wrapping Operation: glEdgeFlagPointer( GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glEdgeFlagPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object>
cConverters: stride=0, pointer=<OpenGL.converters.getPyArgsName object>
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>
returnValues: <OpenGL.converters.returnPyArgument object>
Wrapping Operation: glEdgeFlagPointer( GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glEdgeFlagv( flag )
pyConverters: flag=
asArraySize(incoming, function, args)
cConverters: flag=<OpenGL.converters.getPyArgsName object>
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>
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>
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>
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>
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>
cConverters: pname=None, params=<OpenGL.converters.getPyArgsName object>
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>
cConverters: pname=None, params=<OpenGL.converters.getPyArgsName object>
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>
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>
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>
cConverters: plane=None, equation=<OpenGL.converters.getPyArgsName object>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
cConverters: target=None, query=None, v=<OpenGL.converters.getPyArgsName object>
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>
cConverters: target=None, query=None, v=<OpenGL.converters.getPyArgsName object>
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>
cConverters: target=None, query=None, v=<OpenGL.converters.getPyArgsName object>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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
glGetTexLevelParameterfv( target,level,pname )
pyConverters: target=None, level=None, pname=None
cConverters: target=None, level=None, pname=None, params=<OpenGL.converters.SizedOutput object>
cResolvers: Not Used
storeValues: Not Used
returnValues:
oldStyleReturn(self, result, baseOperation, pyArgs, cArgs) method of SizedOutput 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.SizedOutput object>
cResolvers: Not Used
storeValues: Not Used
returnValues:
oldStyleReturn(self, result, baseOperation, pyArgs, cArgs) method of SizedOutput instance
Retrieve cArgs[ self.index ]
Wrapping Operation: glGetTexLevelParameteriv( GLenum(target), GLint(level), 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>
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>
returnValues: <OpenGL.converters.returnPyArgument object>
Wrapping Operation: glIndexPointer( GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glIndexPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object>
cConverters: type=GL_BYTE, stride=0, pointer=<OpenGL.converters.getPyArgsName object>
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>
returnValues: <OpenGL.converters.returnPyArgument object>
Wrapping Operation: glIndexPointer( GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glIndexPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object>
cConverters: type=GL_DOUBLE, stride=0, pointer=<OpenGL.converters.getPyArgsName object>
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>
returnValues: <OpenGL.converters.returnPyArgument object>
Wrapping Operation: glIndexPointer( GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glIndexPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object>
cConverters: type=GL_FLOAT, stride=0, pointer=<OpenGL.converters.getPyArgsName object>
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>
returnValues: <OpenGL.converters.returnPyArgument object>
Wrapping Operation: glIndexPointer( GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glIndexPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object>
cConverters: type=GL_INT, stride=0, pointer=<OpenGL.converters.getPyArgsName object>
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>
returnValues: <OpenGL.converters.returnPyArgument object>
Wrapping Operation: glIndexPointer( GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glIndexPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object>
cConverters: type=GL_SHORT, stride=0, pointer=<OpenGL.converters.getPyArgsName object>
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>
returnValues: <OpenGL.converters.returnPyArgument object>
Wrapping Operation: glIndexPointer( GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glIndexPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object>
cConverters: type=GL_UNSIGNED_BYTE, stride=0, pointer=<OpenGL.converters.getPyArgsName object>
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>
returnValues: <OpenGL.converters.returnPyArgument object>
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>
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>
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>
cConverters: c=<OpenGL.converters.getPyArgsName object>
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>
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>
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>
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>
cConverters: light=None, pname=None, params=<OpenGL.converters.getPyArgsName object>
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>
cConverters: pname=None, params=<OpenGL.converters.getPyArgsName object>
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>
cConverters: pname=None, params=<OpenGL.converters.getPyArgsName object>
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>
cConverters: light=None, pname=None, params=<OpenGL.converters.getPyArgsName object>
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>
cConverters: light=None, pname=None, params=<OpenGL.converters.getPyArgsName object>
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>
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>
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>
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>
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>
cConverters: face=None, pname=None, params=<OpenGL.converters.getPyArgsName object>
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>
cConverters: face=None, pname=None, params=<OpenGL.converters.getPyArgsName object>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
returnValues: <OpenGL.converters.returnPyArgument object>
Wrapping Operation: glNormalPointer( GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glNormalPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object>
cConverters: type=GL_BYTE, stride=0, pointer=<OpenGL.converters.getPyArgsName object>
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>
returnValues: <OpenGL.converters.returnPyArgument object>
Wrapping Operation: glNormalPointer( GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glNormalPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object>
cConverters: type=GL_DOUBLE, stride=0, pointer=<OpenGL.converters.getPyArgsName object>
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>
returnValues: <OpenGL.converters.returnPyArgument object>
Wrapping Operation: glNormalPointer( GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glNormalPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object>
cConverters: type=GL_FLOAT, stride=0, pointer=<OpenGL.converters.getPyArgsName object>
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>
returnValues: <OpenGL.converters.returnPyArgument object>
Wrapping Operation: glNormalPointer( GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glNormalPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object>
cConverters: type=GL_INT, stride=0, pointer=<OpenGL.converters.getPyArgsName object>
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>
returnValues: <OpenGL.converters.returnPyArgument object>
Wrapping Operation: glNormalPointer( GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glNormalPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object>
cConverters: type=GL_SHORT, stride=0, pointer=<OpenGL.converters.getPyArgsName object>
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>
returnValues: <OpenGL.converters.returnPyArgument object>
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>
cConverters: map=None, mapsize=None, values=<OpenGL.converters.getPyArgsName object>
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>
cConverters: map=None, mapsize=None, values=<OpenGL.converters.getPyArgsName object>
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>
cConverters: map=None, mapsize=None, values=<OpenGL.converters.getPyArgsName object>
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>
cConverters: mask=<OpenGL.converters.getPyArgsName object>
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>, priorities=<OpenGL.converters.CallFuncPyConverter object>
cConverters: n=None, textures=<OpenGL.converters.getPyArgsName object>, priorities=<OpenGL.converters.getPyArgsName object>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>, v2=<OpenGL.converters.CallFuncPyConverter object>
cConverters: v1=<OpenGL.converters.getPyArgsName object>, v2=<OpenGL.converters.getPyArgsName object>
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=None, v2=
asArraySize(incoming, function, args)
cConverters: v1=None, v2=<OpenGL.converters.getPyArgsName object>
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=None, v2=
asArraySize(incoming, function, args)
cConverters: v1=None, v2=<OpenGL.converters.getPyArgsName object>
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=None, v2=
asArraySize(incoming, function, args)
cConverters: v1=None, v2=<OpenGL.converters.getPyArgsName object>
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
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>, column=<OpenGL.GL.images.ImageInputConverter object>
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>
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
glTexCoord1d(...)
glTexCoord1d( GLdouble(s) ) -> None
glTexCoord1dv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
returnValues: <OpenGL.converters.returnPyArgument object>
Wrapping Operation: glTexCoordPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glTexCoordPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object>
cConverters: size=
arraySizeOfFirst(pyArgs, index, baseOperation)
Return the array size of the first argument
, type=GL_BYTE, stride=0, pointer=<OpenGL.converters.getPyArgsName object>
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>
returnValues: <OpenGL.converters.returnPyArgument object>
Wrapping Operation: glTexCoordPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glTexCoordPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object>
cConverters: size=
arraySizeOfFirst(pyArgs, index, baseOperation)
Return the array size of the first argument
, type=GL_DOUBLE, stride=0, pointer=<OpenGL.converters.getPyArgsName object>
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>
returnValues: <OpenGL.converters.returnPyArgument object>
Wrapping Operation: glTexCoordPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glTexCoordPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object>
cConverters: size=
arraySizeOfFirst(pyArgs, index, baseOperation)
Return the array size of the first argument
, type=GL_FLOAT, stride=0, pointer=<OpenGL.converters.getPyArgsName object>
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>
returnValues: <OpenGL.converters.returnPyArgument object>
Wrapping Operation: glTexCoordPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glTexCoordPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object>
cConverters: size=
arraySizeOfFirst(pyArgs, index, baseOperation)
Return the array size of the first argument
, type=GL_INT, stride=0, pointer=<OpenGL.converters.getPyArgsName object>
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>
returnValues: <OpenGL.converters.returnPyArgument object>
Wrapping Operation: glTexCoordPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glTexCoordPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object>
cConverters: size=
arraySizeOfFirst(pyArgs, index, baseOperation)
Return the array size of the first argument
, type=GL_SHORT, stride=0, pointer=<OpenGL.converters.getPyArgsName object>
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>
returnValues: <OpenGL.converters.returnPyArgument object>
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>
cConverters: target=None, pname=None, params=<OpenGL.converters.getPyArgsName object>
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>
cConverters: target=None, pname=None, params=<OpenGL.converters.getPyArgsName object>
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>
cConverters: coord=None, pname=None, params=<OpenGL.converters.getPyArgsName object>
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>
cConverters: coord=None, pname=None, params=<OpenGL.converters.getPyArgsName object>
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>
cConverters: coord=None, pname=None, params=<OpenGL.converters.getPyArgsName object>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
cConverters: target=None, pname=None, params=<OpenGL.converters.getPyArgsName object>
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>
cConverters: target=None, pname=None, params=<OpenGL.converters.getPyArgsName object>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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
glUniformMatrix3fv(...)
glUniformMatrix3fv( GLint(location), GLsizei(count), GLboolean(transpose), GLfloatArray(value) ) -> None
glUniformMatrix4fv(...)
glUniformMatrix4fv( 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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
returnValues: <OpenGL.converters.returnPyArgument object>
Wrapping Operation: glVertexPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glVertexPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object>
cConverters: size=
arraySizeOfFirst(pyArgs, index, baseOperation)
Return the array size of the first argument
, type=GL_INT, stride=0, pointer=<OpenGL.converters.getPyArgsName object>
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>
returnValues: <OpenGL.converters.returnPyArgument object>
Wrapping Operation: glVertexPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glVertexPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object>
cConverters: size=
arraySizeOfFirst(pyArgs, index, baseOperation)
Return the array size of the first argument
, type=GL_DOUBLE, stride=0, pointer=<OpenGL.converters.getPyArgsName object>
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>
returnValues: <OpenGL.converters.returnPyArgument object>
Wrapping Operation: glVertexPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glVertexPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object>
cConverters: size=
arraySizeOfFirst(pyArgs, index, baseOperation)
Return the array size of the first argument
, type=GL_FLOAT, stride=0, pointer=<OpenGL.converters.getPyArgsName object>
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>
returnValues: <OpenGL.converters.returnPyArgument object>
Wrapping Operation: glVertexPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glVertexPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object>
cConverters: size=
arraySizeOfFirst(pyArgs, index, baseOperation)
Return the array size of the first argument
, type=GL_INT, stride=0, pointer=<OpenGL.converters.getPyArgsName object>
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>
returnValues: <OpenGL.converters.returnPyArgument object>
Wrapping Operation: glVertexPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glVertexPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object>
cConverters: size=
arraySizeOfFirst(pyArgs, index, baseOperation)
Return the array size of the first argument
, type=GL_SHORT, stride=0, pointer=<OpenGL.converters.getPyArgsName object>
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>
returnValues: <OpenGL.converters.returnPyArgument object>
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
gluBeginCurve(...)
gluBeginCurve( POINTER(GLUnurbs)(nurb) ) -> None
gluBeginPolygon(...)
gluBeginPolygon( POINTER(GLUtesselator)(tess) ) -> None
gluBeginSurface(...)
gluBeginSurface( POINTER(GLUnurbs)(nurb) ) -> None
gluBeginTrim(...)
gluBeginTrim( POINTER(GLUnurbs)(nurb) ) -> None
gluBuild1DMipmapLevels(...)
gluBuild1DMipmapLevels( GLenum(target), GLint(internalFormat), GLsizei(width), GLenum(format), GLenum(type), GLint(level), GLint(base), GLint(max), c_void_p(data) ) -> GLint
gluBuild1DMipmaps(...)
gluBuild1DMipmaps( GLenum(target), GLint(internalFormat), GLsizei(width), GLenum(format), GLenum(type), c_void_p(data) ) -> GLint
gluBuild2DMipmapLevels(...)
gluBuild2DMipmapLevels( GLenum(target), GLint(internalFormat), GLsizei(width), GLsizei(height), GLenum(format), GLenum(type), GLint(level), GLint(base), GLint(max), c_void_p(data) ) -> GLint
gluBuild2DMipmaps(...)
gluBuild2DMipmaps( GLenum(target), GLint(internalFormat), GLsizei(width), GLsizei(height), GLenum(format), GLenum(type), c_void_p(data) ) -> GLint
gluBuild3DMipmapLevels(...)
gluBuild3DMipmapLevels( GLenum(target), GLint(internalFormat), GLsizei(width), GLsizei(height), GLsizei(depth), GLenum(format), GLenum(type), GLint(level), GLint(base), GLint(max), c_void_p(data) ) -> GLint
gluBuild3DMipmaps(...)
gluBuild3DMipmaps( GLenum(target), GLint(internalFormat), GLsizei(width), GLsizei(height), GLsizei(depth), GLenum(format), GLenum(type), c_void_p(data) ) -> GLint
gluCheckExtension( extName,extString )
pyConverters: extName=<OpenGL.converters.CallFuncPyConverter object>, extString=<OpenGL.converters.CallFuncPyConverter object>
cConverters: extName=<OpenGL.converters.getPyArgsName object>, extString=<OpenGL.converters.getPyArgsName object>
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: gluCheckExtension( arrays.GLubyteArray(extName), arrays.GLubyteArray(extString) ) -> GLboolean
gluCylinder(...)
gluCylinder( POINTER(GLUquadric)(quad), GLdouble(base), GLdouble(top), GLdouble(height), GLint(slices), GLint(stacks) ) -> None
gluDeleteNurbsRenderer(...)
gluDeleteNurbsRenderer( POINTER(GLUnurbs)(nurb) ) -> None
gluDeleteQuadric(...)
gluDeleteQuadric( POINTER(GLUquadric)(quad) ) -> None
gluDeleteTess(...)
gluDeleteTess( POINTER(GLUtesselator)(tess) ) -> None
gluDisk(...)
gluDisk( POINTER(GLUquadric)(quad), GLdouble(inner), GLdouble(outer), GLint(slices), GLint(loops) ) -> None
gluEndCurve(...)
gluEndCurve( POINTER(GLUnurbs)(nurb) ) -> None
gluEndPolygon(...)
gluEndPolygon( POINTER(GLUtesselator)(tess) ) -> None
gluEndSurface(...)
gluEndSurface( POINTER(GLUnurbs)(nurb) ) -> None
gluEndTrim(...)
gluEndTrim( POINTER(GLUnurbs)(nurb) ) -> None
gluErrorString(...)
gluErrorString( GLenum(error) ) -> POINTER(GLubyte)
gluGetNurbsProperty( nurb,property,data )
pyConverters: nurb=None, property=None, data=<OpenGL.converters.CallFuncPyConverter object>
cConverters: nurb=None, property=None, data=<OpenGL.converters.getPyArgsName object>
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: gluGetNurbsProperty( POINTER(GLUnurbs)(nurb), GLenum(property), arrays.GLfloatArray(data) ) -> None
gluGetString(...)
gluGetString( GLenum(name) ) -> POINTER(GLubyte)
gluLoadSamplingMatrices( nurb,model,perspective,view )
pyConverters: nurb=None, model=<OpenGL.converters.CallFuncPyConverter object>, perspective=<OpenGL.converters.CallFuncPyConverter object>, view=<OpenGL.converters.CallFuncPyConverter object>
cConverters: nurb=None, model=<OpenGL.converters.getPyArgsName object>, perspective=<OpenGL.converters.getPyArgsName object>, view=<OpenGL.converters.getPyArgsName object>
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: gluLoadSamplingMatrices( POINTER(GLUnurbs)(nurb), arrays.GLfloatArray(model), arrays.GLfloatArray(perspective), arrays.GLintArray(view) ) -> None
gluLookAt(...)
gluLookAt( GLdouble(eyeX), GLdouble(eyeY), GLdouble(eyeZ), GLdouble(centerX), GLdouble(centerY), GLdouble(centerZ), GLdouble(upX), GLdouble(upY), GLdouble(upZ) ) -> None
gluNewQuadric(...)
gluNewQuadric(  ) -> GLUQuadric
        
Create a new GLUQuadric object
gluNextContour(...)
gluNextContour( POINTER(GLUtesselator)(tess), GLenum(type) ) -> None
gluNurbsProperty(...)
gluNurbsProperty( POINTER(GLUnurbs)(nurb), GLenum(property), GLfloat(value) ) -> None
gluOrtho2D(...)
gluOrtho2D( GLdouble(left), GLdouble(right), GLdouble(bottom), GLdouble(top) ) -> None
gluPartialDisk(...)
gluPartialDisk( POINTER(GLUquadric)(quad), GLdouble(inner), GLdouble(outer), GLint(slices), GLint(loops), GLdouble(start), GLdouble(sweep) ) -> None
gluPerspective(...)
gluPerspective( GLdouble(fovy), GLdouble(aspect), GLdouble(zNear), GLdouble(zFar) ) -> None
gluPickMatrix( x,y,delX,delY,viewport )
pyConverters: x=None, y=None, delX=None, delY=None, viewport=<OpenGL.converters.CallFuncPyConverter object>
cConverters: x=None, y=None, delX=None, delY=None, viewport=<OpenGL.converters.getPyArgsName object>
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: gluPickMatrix( GLdouble(x), GLdouble(y), GLdouble(delX), GLdouble(delY), arrays.GLintArray(viewport) ) -> None
gluQuadricDrawStyle(...)
gluQuadricDrawStyle( POINTER(GLUquadric)(quad), GLenum(draw) ) -> None
gluQuadricNormals(...)
gluQuadricNormals( POINTER(GLUquadric)(quad), GLenum(normal) ) -> None
gluQuadricOrientation(...)
gluQuadricOrientation( POINTER(GLUquadric)(quad), GLenum(orientation) ) -> None
gluQuadricTexture(...)
gluQuadricTexture( POINTER(GLUquadric)(quad), GLboolean(texture) ) -> None
gluScaleImage(...)
gluScaleImage( GLenum(format), GLsizei(wIn), GLsizei(hIn), GLenum(typeIn), c_void_p(dataIn), GLsizei(wOut), GLsizei(hOut), GLenum(typeOut), POINTER(GLvoid)(dataOut) ) -> GLint
gluSphere(...)
gluSphere( POINTER(GLUquadric)(quad), GLdouble(radius), GLint(slices), GLint(stacks) ) -> None
gluTessBeginContour(...)
gluTessBeginContour( POINTER(GLUtesselator)(tess) ) -> None
gluTessEndContour(...)
gluTessEndContour( POINTER(GLUtesselator)(tess) ) -> None
gluTessEndPolygon(...)
gluTessEndPolygon( POINTER(GLUtesselator)(tess) ) -> None
gluTessNormal(...)
gluTessNormal( POINTER(GLUtesselator)(tess), GLdouble(valueX), GLdouble(valueY), GLdouble(valueZ) ) -> None
gluTessProperty(...)
gluTessProperty( POINTER(GLUtesselator)(tess), GLenum(which), GLdouble(data) ) -> None
glutAddMenuEntry(...)
glutAddMenuEntry( STRING(label), c_int(value) ) -> None
glutAddSubMenu(...)
glutAddSubMenu( STRING(label), c_int(subMenu) ) -> None
glutAttachMenu(...)
glutAttachMenu( c_int(button) ) -> None
glutBitmapCharacter(...)
glutBitmapCharacter( c_void_p(font), c_int(character) ) -> None
glutBitmapLength(...)
glutBitmapLength( c_void_p(font), POINTER(c_ubyte)(string) ) -> c_int
glutBitmapWidth(...)
glutBitmapWidth( c_void_p(font), c_int(character) ) -> c_int
glutChangeToMenuEntry(...)
glutChangeToMenuEntry( c_int(item), STRING(label), c_int(value) ) -> None
glutChangeToSubMenu(...)
glutChangeToSubMenu( c_int(item), STRING(label), c_int(value) ) -> None
glutCopyColormap(...)
glutCopyColormap( c_int(window) ) -> None
glutCreateSubWindow(...)
glutCreateSubWindow( c_int(window), c_int(x), c_int(y), c_int(width), c_int(height) ) -> c_int
glutCreateWindow(...)
glutCreateWindow( STRING(title) ) -> c_int
glutDetachMenu(...)
glutDetachMenu( c_int(button) ) -> None
glutDeviceGet(...)
glutDeviceGet( GLenum(query) ) -> c_int
glutEnterGameMode(...)
glutEnterGameMode(  ) -> c_int
glutEstablishOverlay(...)
glutEstablishOverlay(  ) -> None
glutExtensionSupported(...)
glutExtensionSupported( STRING(extension) ) -> c_int
glutForceJoystickFunc(...)
glutForceJoystickFunc(  ) -> None
glutFullScreen(...)
glutFullScreen(  ) -> None
glutGameModeGet(...)
glutGameModeGet( GLenum(query) ) -> c_int
glutGameModeString(...)
glutGameModeString( STRING(string) ) -> None
glutGet(...)
glutGet( GLenum(query) ) -> c_int
glutGetColor(...)
glutGetColor( c_int(color), c_int(component) ) -> GLfloat
glutGetMenu(...)
glutGetMenu(  ) -> c_int
glutGetModifiers(...)
glutGetModifiers(  ) -> c_int
glutGetProcAddress(...)
glutGetProcAddress( STRING(procName) ) -> c_void_p
glutGetWindow(...)
glutGetWindow(  ) -> c_int
glutHideOverlay(...)
glutHideOverlay(  ) -> None
glutHideWindow(...)
glutHideWindow(  ) -> None
glutIconifyWindow(...)
glutIconifyWindow(  ) -> None
glutIgnoreKeyRepeat(...)
glutIgnoreKeyRepeat( c_int(ignore) ) -> None
glutInitDisplayMode(...)
glutInitDisplayMode( c_uint(displayMode) ) -> None
glutInitDisplayString(...)
glutInitDisplayString( STRING(displayMode) ) -> None
glutInitWindowPosition(...)
glutInitWindowPosition( c_int(x), c_int(y) ) -> None
glutInitWindowSize(...)
glutInitWindowSize( c_int(width), c_int(height) ) -> None
glutLayerGet(...)
glutLayerGet( GLenum(query) ) -> c_int
glutLeaveGameMode(...)
glutLeaveGameMode(  ) -> None
glutMainLoop(...)
glutMainLoop(  ) -> None
glutPopWindow(...)
glutPopWindow(  ) -> None
glutPositionWindow(...)
glutPositionWindow( c_int(x), c_int(y) ) -> None
glutPostOverlayRedisplay(...)
glutPostOverlayRedisplay(  ) -> None
glutPostRedisplay(...)
glutPostRedisplay(  ) -> None
glutPostWindowOverlayRedisplay(...)
glutPostWindowOverlayRedisplay( c_int(window) ) -> None
glutPostWindowRedisplay(...)
glutPostWindowRedisplay( c_int(window) ) -> None
glutPushWindow(...)
glutPushWindow(  ) -> None
glutRemoveMenuItem(...)
glutRemoveMenuItem( c_int(item) ) -> None
glutRemoveOverlay(...)
glutRemoveOverlay(  ) -> None
glutReportErrors(...)
glutReportErrors(  ) -> None
glutReshapeWindow(...)
glutReshapeWindow( c_int(width), c_int(height) ) -> None
glutSetColor(...)
glutSetColor( c_int(color), GLfloat(red), GLfloat(green), GLfloat(blue) ) -> None
glutSetCursor(...)
glutSetCursor( c_int(cursor) ) -> None
glutSetIconTitle(...)
glutSetIconTitle( STRING(title) ) -> None
glutSetKeyRepeat(...)
glutSetKeyRepeat( c_int(repeatMode) ) -> None
glutSetMenu(...)
glutSetMenu( c_int(menu) ) -> None
glutSetWindow(...)
glutSetWindow( c_int(window) ) -> None
glutSetWindowTitle(...)
glutSetWindowTitle( STRING(title) ) -> None
glutSetupVideoResizing(...)
glutSetupVideoResizing(  ) -> None
glutShowOverlay(...)
glutShowOverlay(  ) -> None
glutShowWindow(...)
glutShowWindow(  ) -> None
glutSolidCone(...)
glutSolidCone( GLdouble(base), GLdouble(height), GLint(slices), GLint(stacks) ) -> None
glutSolidCube(...)
glutSolidCube( GLdouble(size) ) -> None
glutSolidDodecahedron(...)
glutSolidDodecahedron(  ) -> None
glutSolidIcosahedron(...)
glutSolidIcosahedron(  ) -> None
glutSolidOctahedron(...)
glutSolidOctahedron(  ) -> None
glutSolidSierpinskiSponge( num_levels,offset,scale )
pyConverters: num_levels=None, offset=<OpenGL.converters.CallFuncPyConverter object>, scale=None
cConverters: num_levels=None, offset=<OpenGL.converters.getPyArgsName object>, scale=None
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: glutSolidSierpinskiSponge( c_int(num_levels), arrays.GLdoubleArray(offset), GLdouble(scale) ) -> None
glutSolidSphere(...)
glutSolidSphere( GLdouble(radius), GLint(slices), GLint(stacks) ) -> None
glutSolidTeapot(...)
glutSolidTeapot( GLdouble(size) ) -> None
glutSolidTetrahedron(...)
glutSolidTetrahedron(  ) -> None
glutSolidTorus(...)
glutSolidTorus( GLdouble(innerRadius), GLdouble(outerRadius), GLint(sides), GLint(rings) ) -> None
glutStopVideoResizing(...)
glutStopVideoResizing(  ) -> None
glutStrokeCharacter(...)
glutStrokeCharacter( c_void_p(font), c_int(character) ) -> None
glutStrokeLength(...)
glutStrokeLength( c_void_p(font), POINTER(c_ubyte)(string) ) -> c_int
glutStrokeWidth(...)
glutStrokeWidth( c_void_p(font), c_int(character) ) -> c_int
glutSwapBuffers(...)
glutSwapBuffers(  ) -> None
glutUseLayer(...)
glutUseLayer( GLenum(layer) ) -> None
glutVideoPan(...)
glutVideoPan( c_int(x), c_int(y), c_int(width), c_int(height) ) -> None
glutVideoResize(...)
glutVideoResize( c_int(x), c_int(y), c_int(width), c_int(height) ) -> None
glutVideoResizeGet(...)
glutVideoResizeGet( GLenum(query) ) -> c_int
glutWarpPointer(...)
glutWarpPointer( c_int(x), c_int(y) ) -> None
glutWireCone(...)
glutWireCone( GLdouble(base), GLdouble(height), GLint(slices), GLint(stacks) ) -> None
glutWireCube(...)
glutWireCube( GLdouble(size) ) -> None
glutWireDodecahedron(...)
glutWireDodecahedron(  ) -> None
glutWireIcosahedron(...)
glutWireIcosahedron(  ) -> None
glutWireOctahedron(...)
glutWireOctahedron(  ) -> None
glutWireSierpinskiSponge( num_levels,offset,scale )
pyConverters: num_levels=None, offset=<OpenGL.converters.CallFuncPyConverter object>, scale=None
cConverters: num_levels=None, offset=<OpenGL.converters.getPyArgsName object>, scale=None
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: glutWireSierpinskiSponge( c_int(num_levels), arrays.GLdoubleArray(offset), GLdouble(scale) ) -> None
glutWireSphere(...)
glutWireSphere( GLdouble(radius), GLint(slices), GLint(stacks) ) -> None
glutWireTeapot(...)
glutWireTeapot( GLdouble(size) ) -> None
glutWireTetrahedron(...)
glutWireTetrahedron(  ) -> None
glutWireTorus(...)
glutWireTorus( GLdouble(innerRadius), GLdouble(outerRadius), GLint(sides), GLint(rings) ) -> None
idle()
ontimer(*args)
testFunction(name)

 
Data
        ARRAY_TYPE_TO_CONSTANT = [('GLclampd', GL_DOUBLE), ('GLclampf', GL_FLOAT), ('GLfloat', GL_FLOAT), ('GLdouble', GL_DOUBLE), ('GLbyte', GL_BYTE), ('GLshort', GL_SHORT), ('GLint', GL_INT), ('GLubyte', GL_UNSIGNED_BYTE), ('GLushort', GL_UNSIGNED_SHORT), ('GLuint', GL_UNSIGNED_INT), ('GLenum', GL_UNSIGNED_INT)]
GLUT = <CDLL 'libglut.so.3', handle 80e7bf0 at b7c164ec>
GLUT_ACCUM = GLUT_ACCUM
GLUT_ACTION_CONTINUE_EXECUTION = GLUT_ACTION_CONTINUE_EXECUTION
GLUT_ACTION_EXIT = GLUT_ACTION_EXIT
GLUT_ACTION_GLUTMAINLOOP_RETURNS = GLUT_ACTION_GLUTMAINLOOP_RETURNS
GLUT_ACTION_ON_WINDOW_CLOSE = GLUT_ACTION_ON_WINDOW_CLOSE
GLUT_ACTIVE_ALT = GLUT_ACTIVE_ALT
GLUT_ACTIVE_CTRL = GLUT_ACTIVE_CTRL
GLUT_ACTIVE_SHIFT = GLUT_ACTIVE_SHIFT
GLUT_ALPHA = GLUT_ALPHA
GLUT_API_VERSION = GLUT_API_VERSION
GLUT_BITMAP_8_BY_13 = c_void_p(-1215710496)
GLUT_BITMAP_9_BY_15 = c_void_p(-1215704160)
GLUT_BITMAP_HELVETICA_10 = c_void_p(-1215697824)
GLUT_BITMAP_HELVETICA_12 = c_void_p(-1215692352)
GLUT_BITMAP_HELVETICA_18 = c_void_p(-1215686880)
GLUT_BITMAP_TIMES_ROMAN_10 = c_void_p(-1215674112)
GLUT_BITMAP_TIMES_ROMAN_24 = c_void_p(-1215668640)
GLUT_BLUE = GLUT_BLUE
GLUT_CREATE_NEW_CONTEXT = GLUT_CREATE_NEW_CONTEXT
GLUT_CURSOR_BOTTOM_LEFT_CORNER = GLUT_CURSOR_BOTTOM_LEFT_CORNER
GLUT_CURSOR_BOTTOM_RIGHT_CORNER = GLUT_CURSOR_BOTTOM_RIGHT_CORNER
GLUT_CURSOR_BOTTOM_SIDE = GLUT_CURSOR_BOTTOM_SIDE
GLUT_CURSOR_CROSSHAIR = GLUT_CURSOR_CROSSHAIR
GLUT_CURSOR_CYCLE = GLUT_CURSOR_CYCLE
GLUT_CURSOR_DESTROY = GLUT_CURSOR_DESTROY
GLUT_CURSOR_FULL_CROSSHAIR = GLUT_CURSOR_FULL_CROSSHAIR
GLUT_CURSOR_HELP = GLUT_CURSOR_HELP
GLUT_CURSOR_INFO = GLUT_CURSOR_INFO
GLUT_CURSOR_INHERIT = GLUT_CURSOR_INHERIT
GLUT_CURSOR_LEFT_ARROW = GLUT_CURSOR_LEFT_ARROW
GLUT_CURSOR_LEFT_RIGHT = GLUT_CURSOR_LEFT_RIGHT
GLUT_CURSOR_LEFT_SIDE = GLUT_CURSOR_LEFT_SIDE
GLUT_CURSOR_NONE = GLUT_CURSOR_NONE
GLUT_CURSOR_RIGHT_ARROW = GLUT_CURSOR_RIGHT_ARROW
GLUT_CURSOR_RIGHT_SIDE = GLUT_CURSOR_RIGHT_SIDE
GLUT_CURSOR_SPRAY = GLUT_CURSOR_SPRAY
GLUT_CURSOR_TEXT = GLUT_CURSOR_TEXT
GLUT_CURSOR_TOP_LEFT_CORNER = GLUT_CURSOR_TOP_LEFT_CORNER
GLUT_CURSOR_TOP_RIGHT_CORNER = GLUT_CURSOR_TOP_RIGHT_CORNER
GLUT_CURSOR_TOP_SIDE = GLUT_CURSOR_TOP_SIDE
GLUT_CURSOR_UP_DOWN = GLUT_CURSOR_UP_DOWN
GLUT_CURSOR_WAIT = GLUT_CURSOR_WAIT
GLUT_DEPTH = GLUT_DEPTH
GLUT_DEVICE_IGNORE_KEY_REPEAT = GLUT_DEVICE_IGNORE_KEY_REPEAT
GLUT_DEVICE_KEY_REPEAT = GLUT_DEVICE_KEY_REPEAT
GLUT_DISPLAY_MODE_POSSIBLE = GLUT_DISPLAY_MODE_POSSIBLE
GLUT_DOUBLE = GLUT_DOUBLE
GLUT_DOWN = GLUT_DOWN
GLUT_ELAPSED_TIME = GLUT_ELAPSED_TIME
GLUT_ENTERED = GLUT_ENTERED
GLUT_FULLY_COVERED = GLUT_FULLY_COVERED
GLUT_FULLY_RETAINED = GLUT_FULLY_RETAINED
GLUT_GAME_MODE_ACTIVE = GLUT_GAME_MODE_ACTIVE
GLUT_GAME_MODE_DISPLAY_CHANGED = GLUT_GAME_MODE_DISPLAY_CHANGED
GLUT_GAME_MODE_HEIGHT = GLUT_GAME_MODE_HEIGHT
GLUT_GAME_MODE_PIXEL_DEPTH = GLUT_GAME_MODE_PIXEL_DEPTH
GLUT_GAME_MODE_POSSIBLE = GLUT_GAME_MODE_POSSIBLE
GLUT_GAME_MODE_REFRESH_RATE = GLUT_GAME_MODE_REFRESH_RATE
GLUT_GAME_MODE_WIDTH = GLUT_GAME_MODE_WIDTH
GLUT_GREEN = GLUT_GREEN
GLUT_GUARD_CALLBACKS = False
GLUT_HAS_DIAL_AND_BUTTON_BOX = GLUT_HAS_DIAL_AND_BUTTON_BOX
GLUT_HAS_JOYSTICK = GLUT_HAS_JOYSTICK
GLUT_HAS_KEYBOARD = GLUT_HAS_KEYBOARD
GLUT_HAS_MOUSE = GLUT_HAS_MOUSE
GLUT_HAS_OVERLAY = GLUT_HAS_OVERLAY
GLUT_HAS_SPACEBALL = GLUT_HAS_SPACEBALL
GLUT_HAS_TABLET = GLUT_HAS_TABLET
GLUT_HIDDEN = GLUT_HIDDEN
GLUT_INDEX = GLUT_INDEX
GLUT_INIT_DISPLAY_MODE = GLUT_INIT_DISPLAY_MODE
GLUT_INIT_STATE = GLUT_INIT_STATE
GLUT_INIT_WINDOW_HEIGHT = GLUT_INIT_WINDOW_HEIGHT
GLUT_INIT_WINDOW_WIDTH = GLUT_INIT_WINDOW_WIDTH
GLUT_INIT_WINDOW_X = GLUT_INIT_WINDOW_X
GLUT_INIT_WINDOW_Y = GLUT_INIT_WINDOW_Y
GLUT_JOYSTICK_AXES = GLUT_JOYSTICK_AXES
GLUT_JOYSTICK_BUTTONS = GLUT_JOYSTICK_BUTTONS
GLUT_JOYSTICK_BUTTON_A = GLUT_JOYSTICK_BUTTON_A
GLUT_JOYSTICK_BUTTON_B = GLUT_JOYSTICK_BUTTON_B
GLUT_JOYSTICK_BUTTON_C = GLUT_JOYSTICK_BUTTON_C
GLUT_JOYSTICK_BUTTON_D = GLUT_JOYSTICK_BUTTON_D
GLUT_JOYSTICK_POLL_RATE = GLUT_JOYSTICK_POLL_RATE
GLUT_KEY_DOWN = GLUT_KEY_DOWN
GLUT_KEY_END = GLUT_KEY_END
GLUT_KEY_F1 = GLUT_KEY_F1
GLUT_KEY_F10 = GLUT_KEY_F10
GLUT_KEY_F11 = GLUT_KEY_F11
GLUT_KEY_F12 = GLUT_KEY_F12
GLUT_KEY_F2 = GLUT_KEY_F2
GLUT_KEY_F3 = GLUT_KEY_F3
GLUT_KEY_F4 = GLUT_KEY_F4
GLUT_KEY_F5 = GLUT_KEY_F5
GLUT_KEY_F6 = GLUT_KEY_F6
GLUT_KEY_F7 = GLUT_KEY_F7
GLUT_KEY_F8 = GLUT_KEY_F8
GLUT_KEY_F9 = GLUT_KEY_F9
GLUT_KEY_HOME = GLUT_KEY_HOME
GLUT_KEY_INSERT = GLUT_KEY_INSERT
GLUT_KEY_LEFT = GLUT_KEY_LEFT
GLUT_KEY_PAGE_DOWN = GLUT_KEY_PAGE_DOWN
GLUT_KEY_PAGE_UP = GLUT_KEY_PAGE_UP
GLUT_KEY_REPEAT_DEFAULT = GLUT_KEY_REPEAT_DEFAULT
GLUT_KEY_REPEAT_OFF = GLUT_KEY_REPEAT_OFF
GLUT_KEY_REPEAT_ON = GLUT_KEY_REPEAT_ON
GLUT_KEY_RIGHT = GLUT_KEY_RIGHT
GLUT_KEY_UP = GLUT_KEY_UP
GLUT_LAYER_IN_USE = GLUT_LAYER_IN_USE
GLUT_LEFT = GLUT_LEFT
GLUT_LEFT_BUTTON = GLUT_LEFT_BUTTON
GLUT_LUMINANCE = GLUT_LUMINANCE
GLUT_MENU_IN_USE = GLUT_MENU_IN_USE
GLUT_MENU_NOT_IN_USE = GLUT_MENU_NOT_IN_USE
GLUT_MENU_NUM_ITEMS = GLUT_MENU_NUM_ITEMS
GLUT_MIDDLE_BUTTON = GLUT_MIDDLE_BUTTON
GLUT_MULTISAMPLE = GLUT_MULTISAMPLE
GLUT_NORMAL = GLUT_NORMAL
GLUT_NORMAL_DAMAGED = GLUT_NORMAL_DAMAGED
GLUT_NOT_VISIBLE = GLUT_NOT_VISIBLE
GLUT_NUM_BUTTON_BOX_BUTTONS = GLUT_NUM_BUTTON_BOX_BUTTONS
GLUT_NUM_DIALS = GLUT_NUM_DIALS
GLUT_NUM_MOUSE_BUTTONS = GLUT_NUM_MOUSE_BUTTONS
GLUT_NUM_SPACEBALL_BUTTONS = GLUT_NUM_SPACEBALL_BUTTONS
GLUT_NUM_TABLET_BUTTONS = GLUT_NUM_TABLET_BUTTONS
GLUT_OVERLAY = GLUT_OVERLAY
GLUT_OVERLAY_DAMAGED = GLUT_OVERLAY_DAMAGED
GLUT_OVERLAY_POSSIBLE = GLUT_OVERLAY_POSSIBLE
GLUT_OWNS_JOYSTICK = GLUT_OWNS_JOYSTICK
GLUT_PARTIALLY_RETAINED = GLUT_PARTIALLY_RETAINED
GLUT_RED = GLUT_RED
GLUT_RENDERING_CONTEXT = GLUT_RENDERING_CONTEXT
GLUT_RGB = GLUT_RGB
GLUT_RGBA = GLUT_RGBA
GLUT_RIGHT_BUTTON = GLUT_RIGHT_BUTTON
GLUT_SCREEN_HEIGHT = GLUT_SCREEN_HEIGHT
GLUT_SCREEN_HEIGHT_MM = GLUT_SCREEN_HEIGHT_MM
GLUT_SCREEN_WIDTH = GLUT_SCREEN_WIDTH
GLUT_SCREEN_WIDTH_MM = GLUT_SCREEN_WIDTH_MM
GLUT_SINGLE = GLUT_SINGLE
GLUT_STENCIL = GLUT_STENCIL
GLUT_STEREO = GLUT_STEREO
GLUT_STROKE_MONO_ROMAN = c_void_p(-1215660536)
GLUT_STROKE_ROMAN = c_void_p(-1215660420)
GLUT_TRANSPARENT_INDEX = GLUT_TRANSPARENT_INDEX
GLUT_UP = GLUT_UP
GLUT_USE_CURRENT_CONTEXT = GLUT_USE_CURRENT_CONTEXT
GLUT_VIDEO_RESIZE_HEIGHT = GLUT_VIDEO_RESIZE_HEIGHT
GLUT_VIDEO_RESIZE_HEIGHT_DELTA = GLUT_VIDEO_RESIZE_HEIGHT_DELTA
GLUT_VIDEO_RESIZE_IN_USE = GLUT_VIDEO_RESIZE_IN_USE
GLUT_VIDEO_RESIZE_POSSIBLE = GLUT_VIDEO_RESIZE_POSSIBLE
GLUT_VIDEO_RESIZE_WIDTH = GLUT_VIDEO_RESIZE_WIDTH
GLUT_VIDEO_RESIZE_WIDTH_DELTA = GLUT_VIDEO_RESIZE_WIDTH_DELTA
GLUT_VIDEO_RESIZE_X = GLUT_VIDEO_RESIZE_X
GLUT_VIDEO_RESIZE_X_DELTA = GLUT_VIDEO_RESIZE_X_DELTA
GLUT_VIDEO_RESIZE_Y = GLUT_VIDEO_RESIZE_Y
GLUT_VIDEO_RESIZE_Y_DELTA = GLUT_VIDEO_RESIZE_Y_DELTA
GLUT_VISIBLE = GLUT_VISIBLE
GLUT_WINDOW_ACCUM_ALPHA_SIZE = GLUT_WINDOW_ACCUM_ALPHA_SIZE
GLUT_WINDOW_ACCUM_BLUE_SIZE = GLUT_WINDOW_ACCUM_BLUE_SIZE
GLUT_WINDOW_ACCUM_GREEN_SIZE = GLUT_WINDOW_ACCUM_GREEN_SIZE
GLUT_WINDOW_ACCUM_RED_SIZE = GLUT_WINDOW_ACCUM_RED_SIZE
GLUT_WINDOW_ALPHA_SIZE = GLUT_WINDOW_ALPHA_SIZE
GLUT_WINDOW_BLUE_SIZE = GLUT_WINDOW_BLUE_SIZE
GLUT_WINDOW_BORDER_WIDTH = GLUT_WINDOW_BORDER_WIDTH
GLUT_WINDOW_BUFFER_SIZE = GLUT_WINDOW_BUFFER_SIZE
GLUT_WINDOW_COLORMAP_SIZE = GLUT_WINDOW_COLORMAP_SIZE
GLUT_WINDOW_CURSOR = GLUT_WINDOW_CURSOR
GLUT_WINDOW_DEPTH_SIZE = GLUT_WINDOW_DEPTH_SIZE
GLUT_WINDOW_DOUBLEBUFFER = GLUT_WINDOW_DOUBLEBUFFER
GLUT_WINDOW_FORMAT_ID = GLUT_WINDOW_FORMAT_ID
GLUT_WINDOW_GREEN_SIZE = GLUT_WINDOW_GREEN_SIZE
GLUT_WINDOW_HEADER_HEIGHT = GLUT_USE_CURRENT_CONTEXT
GLUT_WINDOW_HEIGHT = GLUT_WINDOW_HEIGHT
GLUT_WINDOW_NUM_CHILDREN = GLUT_WINDOW_NUM_CHILDREN
GLUT_WINDOW_NUM_SAMPLES = GLUT_WINDOW_NUM_SAMPLES
GLUT_WINDOW_PARENT = GLUT_WINDOW_PARENT
GLUT_WINDOW_RED_SIZE = GLUT_WINDOW_RED_SIZE
GLUT_WINDOW_RGBA = GLUT_WINDOW_RGBA
GLUT_WINDOW_STENCIL_SIZE = GLUT_WINDOW_STENCIL_SIZE
GLUT_WINDOW_STEREO = GLUT_WINDOW_STEREO
GLUT_WINDOW_WIDTH = GLUT_WINDOW_WIDTH
GLUT_WINDOW_X = GLUT_WINDOW_X
GLUT_WINDOW_Y = GLUT_WINDOW_Y
GLUT_XLIB_IMPLEMENTATION = GLUT_XLIB_IMPLEMENTATION
GLU_AUTO_LOAD_MATRIX = GLU_AUTO_LOAD_MATRIX
GLU_BEGIN = GLU_BEGIN
GLU_CCW = GLU_CCW
GLU_CULLING = GLU_CULLING
GLU_CW = GLU_CW
GLU_DISPLAY_MODE = GLU_DISPLAY_MODE
GLU_DOMAIN_DISTANCE = GLU_DOMAIN_DISTANCE
GLU_EDGE_FLAG = GLU_EDGE_FLAG
GLU_END = GLU_END
GLU_ERROR = GLU_ERROR
GLU_EXTENSIONS = GLU_EXTENSIONS
GLU_EXTERIOR = GLU_EXTERIOR
GLU_FALSE = GLU_FALSE
GLU_FILL = GLU_FILL
GLU_FLAT = GLU_FLAT
GLU_INCOMPATIBLE_GL_VERSION = GLU_INCOMPATIBLE_GL_VERSION
GLU_INSIDE = GLU_INSIDE
GLU_INTERIOR = GLU_INTERIOR
GLU_INVALID_ENUM = GLU_INVALID_ENUM
GLU_INVALID_OPERATION = GLU_INVALID_OPERATION
GLU_INVALID_VALUE = GLU_INVALID_VALUE
GLU_LINE = GLU_LINE
GLU_MAP1_TRIM_2 = GLU_MAP1_TRIM_2
GLU_MAP1_TRIM_3 = GLU_MAP1_TRIM_3
GLU_NONE = GLU_NONE
GLU_NURBS_BEGIN = GLU_NURBS_BEGIN
GLU_NURBS_BEGIN_DATA = GLU_NURBS_BEGIN_DATA
GLU_NURBS_BEGIN_DATA_EXT = GLU_NURBS_BEGIN_DATA_EXT
GLU_NURBS_BEGIN_EXT = GLU_NURBS_BEGIN_EXT
GLU_NURBS_COLOR = GLU_NURBS_COLOR
GLU_NURBS_COLOR_DATA = GLU_NURBS_COLOR_DATA
GLU_NURBS_COLOR_DATA_EXT = GLU_NURBS_COLOR_DATA_EXT
GLU_NURBS_COLOR_EXT = GLU_NURBS_COLOR_EXT
GLU_NURBS_END = GLU_NURBS_END
GLU_NURBS_END_DATA = GLU_NURBS_END_DATA
GLU_NURBS_END_DATA_EXT = GLU_NURBS_END_DATA_EXT
GLU_NURBS_END_EXT = GLU_NURBS_END_EXT
GLU_NURBS_ERROR = GLU_NURBS_ERROR
GLU_NURBS_ERROR1 = GLU_NURBS_ERROR1
GLU_NURBS_ERROR10 = GLU_NURBS_ERROR10
GLU_NURBS_ERROR11 = GLU_NURBS_ERROR11
GLU_NURBS_ERROR12 = GLU_NURBS_ERROR12
GLU_NURBS_ERROR13 = GLU_NURBS_ERROR13
GLU_NURBS_ERROR14 = GLU_NURBS_ERROR14
GLU_NURBS_ERROR15 = GLU_NURBS_ERROR15
GLU_NURBS_ERROR16 = GLU_NURBS_ERROR16
GLU_NURBS_ERROR17 = GLU_NURBS_ERROR17
GLU_NURBS_ERROR18 = GLU_NURBS_ERROR18
GLU_NURBS_ERROR19 = GLU_NURBS_ERROR19
GLU_NURBS_ERROR2 = GLU_NURBS_ERROR2
GLU_NURBS_ERROR20 = GLU_NURBS_ERROR20
GLU_NURBS_ERROR21 = GLU_NURBS_ERROR21
GLU_NURBS_ERROR22 = GLU_NURBS_ERROR22
GLU_NURBS_ERROR23 = GLU_NURBS_ERROR23
GLU_NURBS_ERROR24 = GLU_NURBS_ERROR24
GLU_NURBS_ERROR25 = GLU_NURBS_ERROR25
GLU_NURBS_ERROR26 = GLU_NURBS_ERROR26
GLU_NURBS_ERROR27 = GLU_NURBS_ERROR27
GLU_NURBS_ERROR28 = GLU_NURBS_ERROR28
GLU_NURBS_ERROR29 = GLU_NURBS_ERROR29
GLU_NURBS_ERROR3 = GLU_NURBS_ERROR3
GLU_NURBS_ERROR30 = GLU_NURBS_ERROR30
GLU_NURBS_ERROR31 = GLU_NURBS_ERROR31
GLU_NURBS_ERROR32 = GLU_NURBS_ERROR32
GLU_NURBS_ERROR33 = GLU_NURBS_ERROR33
GLU_NURBS_ERROR34 = GLU_NURBS_ERROR34
GLU_NURBS_ERROR35 = GLU_NURBS_ERROR35
GLU_NURBS_ERROR36 = GLU_NURBS_ERROR36
GLU_NURBS_ERROR37 = GLU_NURBS_ERROR37
GLU_NURBS_ERROR4 = GLU_NURBS_ERROR4
GLU_NURBS_ERROR5 = GLU_NURBS_ERROR5
GLU_NURBS_ERROR6 = GLU_NURBS_ERROR6
GLU_NURBS_ERROR7 = GLU_NURBS_ERROR7
GLU_NURBS_ERROR8 = GLU_NURBS_ERROR8
GLU_NURBS_ERROR9 = GLU_NURBS_ERROR9
GLU_NURBS_MODE = GLU_NURBS_MODE
GLU_NURBS_MODE_EXT = GLU_NURBS_MODE_EXT
GLU_NURBS_NORMAL = GLU_NURBS_NORMAL
GLU_NURBS_NORMAL_DATA = GLU_NURBS_NORMAL_DATA
GLU_NURBS_NORMAL_DATA_EXT = GLU_NURBS_NORMAL_DATA_EXT
GLU_NURBS_NORMAL_EXT = GLU_NURBS_NORMAL_EXT
GLU_NURBS_RENDERER = GLU_NURBS_RENDERER
GLU_NURBS_RENDERER_EXT = GLU_NURBS_RENDERER_EXT
GLU_NURBS_TESSELLATOR = GLU_NURBS_TESSELLATOR
GLU_NURBS_TESSELLATOR_EXT = GLU_NURBS_TESSELLATOR_EXT
GLU_NURBS_TEXTURE_COORD = GLU_NURBS_TEXTURE_COORD
GLU_NURBS_TEXTURE_COORD_DATA = GLU_NURBS_TEXTURE_COORD_DATA
GLU_NURBS_TEX_COORD_DATA_EXT = GLU_NURBS_TEX_COORD_DATA_EXT
GLU_NURBS_TEX_COORD_EXT = GLU_NURBS_TEX_COORD_EXT
GLU_NURBS_VERTEX = GLU_NURBS_VERTEX
GLU_NURBS_VERTEX_DATA = GLU_NURBS_VERTEX_DATA
GLU_NURBS_VERTEX_DATA_EXT = GLU_NURBS_VERTEX_DATA_EXT
GLU_NURBS_VERTEX_EXT = GLU_NURBS_VERTEX_EXT
GLU_OBJECT_PARAMETRIC_ERROR = GLU_OBJECT_PARAMETRIC_ERROR
GLU_OBJECT_PARAMETRIC_ERROR_EXT = GLU_OBJECT_PARAMETRIC_ERROR_EXT
GLU_OBJECT_PATH_LENGTH = GLU_OBJECT_PATH_LENGTH
GLU_OBJECT_PATH_LENGTH_EXT = GLU_OBJECT_PATH_LENGTH_EXT
GLU_OUTLINE_PATCH = GLU_OUTLINE_PATCH
GLU_OUTLINE_POLYGON = GLU_OUTLINE_POLYGON
GLU_OUTSIDE = GLU_OUTSIDE
GLU_OUT_OF_MEMORY = GLU_OUT_OF_MEMORY
GLU_PARAMETRIC_ERROR = GLU_PARAMETRIC_ERROR
GLU_PARAMETRIC_TOLERANCE = GLU_PARAMETRIC_TOLERANCE
GLU_PATH_LENGTH = GLU_PATH_LENGTH
GLU_POINT = GLU_POINT
GLU_SAMPLING_METHOD = GLU_SAMPLING_METHOD
GLU_SAMPLING_TOLERANCE = GLU_SAMPLING_TOLERANCE
GLU_SILHOUETTE = GLU_SILHOUETTE
GLU_SMOOTH = GLU_SMOOTH
GLU_TESS_BEGIN = GLU_TESS_BEGIN
GLU_TESS_BEGIN_DATA = GLU_TESS_BEGIN_DATA
GLU_TESS_BOUNDARY_ONLY = GLU_TESS_BOUNDARY_ONLY
GLU_TESS_COMBINE = GLU_TESS_COMBINE
GLU_TESS_COMBINE_DATA = GLU_TESS_COMBINE_DATA
GLU_TESS_COORD_TOO_LARGE = GLU_TESS_COORD_TOO_LARGE
GLU_TESS_EDGE_FLAG = GLU_TESS_EDGE_FLAG
GLU_TESS_EDGE_FLAG_DATA = GLU_TESS_EDGE_FLAG_DATA
GLU_TESS_END = GLU_TESS_END
GLU_TESS_END_DATA = GLU_TESS_END_DATA
GLU_TESS_ERROR = GLU_TESS_ERROR
GLU_TESS_ERROR1 = GLU_TESS_ERROR1
GLU_TESS_ERROR2 = GLU_TESS_ERROR2
GLU_TESS_ERROR3 = GLU_TESS_ERROR3
GLU_TESS_ERROR4 = GLU_TESS_ERROR4
GLU_TESS_ERROR5 = GLU_TESS_ERROR5
GLU_TESS_ERROR6 = GLU_TESS_ERROR6
GLU_TESS_ERROR7 = GLU_TESS_ERROR7
GLU_TESS_ERROR8 = GLU_TESS_ERROR8
GLU_TESS_ERROR_DATA = GLU_TESS_ERROR_DATA
GLU_TESS_MAX_COORD = GLU_TESS_MAX_COORD
GLU_TESS_MISSING_BEGIN_CONTOUR = GLU_TESS_MISSING_BEGIN_CONTOUR
GLU_TESS_MISSING_BEGIN_POLYGON = GLU_TESS_MISSING_BEGIN_POLYGON
GLU_TESS_MISSING_END_CONTOUR = GLU_TESS_MISSING_END_CONTOUR
GLU_TESS_MISSING_END_POLYGON = GLU_TESS_MISSING_END_POLYGON
GLU_TESS_NEED_COMBINE_CALLBACK = GLU_TESS_NEED_COMBINE_CALLBACK
GLU_TESS_TOLERANCE = GLU_TESS_TOLERANCE
GLU_TESS_VERTEX = GLU_TESS_VERTEX
GLU_TESS_VERTEX_DATA = GLU_TESS_VERTEX_DATA
GLU_TESS_WINDING_ABS_GEQ_TWO = GLU_TESS_WINDING_ABS_GEQ_TWO
GLU_TESS_WINDING_NEGATIVE = GLU_TESS_WINDING_NEGATIVE
GLU_TESS_WINDING_NONZERO = GLU_TESS_WINDING_NONZERO
GLU_TESS_WINDING_ODD = GLU_TESS_WINDING_ODD
GLU_TESS_WINDING_POSITIVE = GLU_TESS_WINDING_POSITIVE
GLU_TESS_WINDING_RULE = GLU_TESS_WINDING_RULE
GLU_TRUE = GLU_TRUE
GLU_UNKNOWN = GLU_UNKNOWN
GLU_U_STEP = GLU_U_STEP
GLU_VERSION = GLU_VERSION
GLU_VERSION_1_1 = GLU_VERSION_1_1
GLU_VERSION_1_2 = GLU_VERSION_1_2
GLU_VERSION_1_3 = GLU_VERSION_1_3
GLU_VERTEX = GLU_VERTEX
GLU_V_STEP = GLU_V_STEP
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_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_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_MAT3 = GL_FLOAT_MAT3
GL_FLOAT_MAT3_ARB = GL_FLOAT_MAT3_ARB
GL_FLOAT_MAT4 = GL_FLOAT_MAT4
GL_FLOAT_MAT4_ARB = GL_FLOAT_MAT4_ARB
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_HALF_NV = GL_HALF_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_ARB = GL_PIXEL_PACK_BUFFER_ARB
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_ARB = GL_PIXEL_UNPACK_BUFFER_ARB
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_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_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
HAVE_FREEGLUT = False
glutBitmapHeight = <OpenGL.platform.glutBitmapHeight object>
glutBitmapString = <OpenGL.platform.glutBitmapString object>
glutButtonBoxFunc = <OpenGL.GLUT.special.GLUTCallback object>
glutCloseFunc = <OpenGL.GLUT.special.GLUTCallback object>
glutDialsFunc = <OpenGL.GLUT.special.GLUTCallback object>
glutDisplayFunc = <OpenGL.GLUT.special.GLUTCallback object>
glutEntryFunc = <OpenGL.GLUT.special.GLUTCallback object>
glutGetMenuData = <OpenGL.platform.glutGetMenuData object>
glutGetWindowData = <OpenGL.platform.glutGetWindowData object>
glutIdleFunc = <OpenGL.GLUT.special.GLUTCallback object>
glutJoystickFunc = <OpenGL.GLUT.special.GLUTCallback object>
glutKeyboardFunc = <OpenGL.GLUT.special.GLUTCallback object>
glutKeyboardUpFunc = <OpenGL.GLUT.special.GLUTCallback object>
glutLeaveMainLoop = <OpenGL.platform.glutLeaveMainLoop object>
glutMainLoopEvent = <OpenGL.platform.glutMainLoopEvent object>
glutMenuDestroyFunc = <OpenGL.GLUT.special.GLUTCallback object>
glutMenuStateFunc = <OpenGL.GLUT.special.GLUTCallback object>
glutMenuStatusFunc = <OpenGL.GLUT.special.GLUTCallback object>
glutMotionFunc = <OpenGL.GLUT.special.GLUTCallback object>
glutMouseFunc = <OpenGL.GLUT.special.GLUTCallback object>
glutMouseWheelFunc = <OpenGL.GLUT.special.GLUTCallback object>
glutOverlayDisplayFunc = <OpenGL.GLUT.special.GLUTCallback object>
glutPassiveMotionFunc = <OpenGL.GLUT.special.GLUTCallback object>
glutReshapeFunc = <OpenGL.GLUT.special.GLUTCallback object>
glutSetMenuData = <OpenGL.platform.glutSetMenuData object>
glutSetOption = <OpenGL.platform.glutSetOption object>
glutSetWindowData = <OpenGL.platform.glutSetWindowData object>
glutSolidCylinder = <OpenGL.platform.glutSolidCylinder object>
glutSolidRhombicDodecahedron = <OpenGL.platform.glutSolidRhombicDodecahedron object>
glutSpaceballButtonFunc = <OpenGL.GLUT.special.GLUTCallback object>
glutSpaceballMotionFunc = <OpenGL.GLUT.special.GLUTCallback object>
glutSpaceballRotateFunc = <OpenGL.GLUT.special.GLUTCallback object>
glutSpecialFunc = <OpenGL.GLUT.special.GLUTCallback object>
glutSpecialUpFunc = <OpenGL.GLUT.special.GLUTCallback object>
glutStrokeHeight = <OpenGL.platform.glutStrokeHeight object>
glutStrokeString = <OpenGL.platform.glutStrokeString object>
glutTabletButtonFunc = <OpenGL.GLUT.special.GLUTCallback object>
glutTabletMotionFunc = <OpenGL.GLUT.special.GLUTCallback object>
glutTimerFunc = <OpenGL.GLUT.special.GLUTTimerCallback object>
glutVisibilityFunc = <OpenGL.GLUT.special.GLUTCallback object>
glutWMCloseFunc = <OpenGL.GLUT.special.GLUTCallback object>
glutWindowStatusFunc = <OpenGL.GLUT.special.GLUTCallback object>
glutWireCylinder = <OpenGL.platform.glutWireCylinder object>
glutWireRhombicDodecahedron = <OpenGL.platform.glutWireRhombicDodecahedron object>
name = 'glUniform4iv'
start = 1171571039.8501329
window = None