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

Array-size annotations for OpenGL.raw.GL
 
Automatically generated by the generateraw script, do not edit!

 
Modules
       
OpenGL.constants
OpenGL.arrays
OpenGL.platform
OpenGL.raw.GL
ctypes.util

 
Functions
       
addressof(...)
addressof(C instance) -> integer
Return the address of the C instance internal buffer
alignment(...)
alignment(C type) -> integer
alignment(C instance) -> integer
Return the alignment requirements of a C instance
byref(...)
byref(C instance) -> byref-object
Return a pointer lookalike to a C instance, only usable
as function argument
glAreTexturesResident( n,textures,residences )
pyConverters: n=None, textures=<OpenGL.converters.CallFuncPyConverter object at 0x828d32c>, residences=None
cConverters: n=None, textures=<OpenGL.converters.getPyArgsName object at 0x8666aa4>, 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
glBitmap( width,height,xorig,yorig,xmove,ymove,bitmap )
pyConverters: width=None, height=None, xorig=None, yorig=None, xmove=None, ymove=None, bitmap=<OpenGL.converters.CallFuncPyConverter object at 0x828d42c>
cConverters: width=None, height=None, xorig=None, yorig=None, xmove=None, ymove=None, bitmap=<OpenGL.converters.getPyArgsName object at 0x8666b1c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glBitmap( GLsizei(width), GLsizei(height), GLfloat(xorig), GLfloat(yorig), GLfloat(xmove), GLfloat(ymove), arrays.GLubyteArray(bitmap) ) -> None
glClipPlane( plane,equation )
pyConverters: plane=None, equation=<OpenGL.converters.CallFuncPyConverter object at 0x828da6c>
cConverters: plane=None, equation=<OpenGL.converters.getPyArgsName object at 0x8666b94>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glClipPlane( GLenum(plane), arrays.GLdoubleArray(equation) ) -> None
glColor3bv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8666c0c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glColor3bv( arrays.GLbyteArray(v) ) -> None
glColor3dv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8666cac>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glColor3dv( arrays.GLdoubleArray(v) ) -> None
glColor3fv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8666d4c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glColor3fv( arrays.GLfloatArray(v) ) -> None
glColor3iv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8666dec>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glColor3iv( arrays.GLintArray(v) ) -> None
glColor3sv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8666e8c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glColor3sv( arrays.GLshortArray(v) ) -> None
glColor3ubv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8666f2c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glColor3ubv( arrays.GLubyteArray(v) ) -> None
glColor3uiv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8666fcc>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glColor3uiv( arrays.GLuintArray(v) ) -> None
glColor3usv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b4c0a4>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glColor3usv( arrays.GLushortArray(v) ) -> None
glColor4bv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b4c144>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glColor4bv( arrays.GLbyteArray(v) ) -> None
glColor4dv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b4c1e4>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glColor4dv( arrays.GLdoubleArray(v) ) -> None
glColor4fv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b4c284>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glColor4fv( arrays.GLfloatArray(v) ) -> None
glColor4iv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b4c324>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glColor4iv( arrays.GLintArray(v) ) -> None
glColor4sv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b4c3c4>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glColor4sv( arrays.GLshortArray(v) ) -> None
glColor4ubv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b4c464>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glColor4ubv( arrays.GLubyteArray(v) ) -> None
glColor4uiv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b4c504>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glColor4uiv( arrays.GLuintArray(v) ) -> None
glColor4usv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b4c5a4>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glColor4usv( arrays.GLushortArray(v) ) -> None
glDeleteTextures( n,textures )
pyConverters: n=None, textures=<OpenGL.converters.CallFuncPyConverter object at 0x87f766c>
cConverters: n=None, textures=<OpenGL.converters.getPyArgsName object at 0x8b4c644>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glDeleteTextures( GLsizei(n), arrays.GLuintArray(textures) ) -> None
glEvalCoord1dv( u )
pyConverters: u=
asArraySize(incoming, function, args)
cConverters: u=<OpenGL.converters.getPyArgsName object at 0x8b4c6bc>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glEvalCoord1dv( arrays.GLdoubleArray(u) ) -> None
glEvalCoord1fv( u )
pyConverters: u=
asArraySize(incoming, function, args)
cConverters: u=<OpenGL.converters.getPyArgsName object at 0x8b4c75c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glEvalCoord1fv( arrays.GLfloatArray(u) ) -> None
glEvalCoord2dv( u )
pyConverters: u=
asArraySize(incoming, function, args)
cConverters: u=<OpenGL.converters.getPyArgsName object at 0x8b4c7fc>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glEvalCoord2dv( arrays.GLdoubleArray(u) ) -> None
glEvalCoord2fv( u )
pyConverters: u=
asArraySize(incoming, function, args)
cConverters: u=<OpenGL.converters.getPyArgsName object at 0x8b4c89c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glEvalCoord2fv( arrays.GLfloatArray(u) ) -> None
glFeedbackBuffer( size,type,buffer )
pyConverters: size=None, type=None, buffer=<OpenGL.converters.CallFuncPyConverter object at 0x87f7cac>
cConverters: size=None, type=None, buffer=<OpenGL.converters.getPyArgsName object at 0x8b4c93c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glFeedbackBuffer( GLsizei(size), GLenum(type), arrays.GLfloatArray(buffer) ) -> None
glFogfv( pname,params )
pyConverters: pname=None, params=<OpenGL.converters.CallFuncPyConverter object at 0x87f7dec>
cConverters: pname=None, params=<OpenGL.converters.getPyArgsName object at 0x8b4c9b4>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glFogfv( GLenum(pname), arrays.GLfloatArray(params) ) -> None
glFogiv( pname,params )
pyConverters: pname=None, params=<OpenGL.converters.CallFuncPyConverter object at 0x87f98cc>
cConverters: pname=None, params=<OpenGL.converters.getPyArgsName object at 0x8b4ca2c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glFogiv( GLenum(pname), arrays.GLintArray(params) ) -> None
glGenTextures( n,textures )
pyConverters: n=None, textures=<OpenGL.converters.CallFuncPyConverter object at 0x87f9f8c>
cConverters: n=None, textures=<OpenGL.converters.getPyArgsName object at 0x8b4caa4>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glGenTextures( GLsizei(n), arrays.GLuintArray(textures) ) -> None
glGetClipPlane( plane,equation )
pyConverters: plane=None, equation=<OpenGL.converters.CallFuncPyConverter object at 0x87f934c>
cConverters: plane=None, equation=<OpenGL.converters.getPyArgsName object at 0x8b4cb1c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glGetClipPlane( GLenum(plane), arrays.GLdoubleArray(equation) ) -> None
glGetDoublev( pname,params )
pyConverters: pname=None, params=<OpenGL.converters.CallFuncPyConverter object at 0x87f97ac>
cConverters: pname=None, params=<OpenGL.converters.getPyArgsName object at 0x8b4cb94>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glGetDoublev( GLenum(pname), arrays.GLdoubleArray(params) ) -> None
glGetFloatv( pname,params )
pyConverters: pname=None, params=<OpenGL.converters.CallFuncPyConverter object at 0x87f93ec>
cConverters: pname=None, params=<OpenGL.converters.getPyArgsName object at 0x8b4cc0c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glGetFloatv( GLenum(pname), arrays.GLfloatArray(params) ) -> None
glGetIntegerv( pname,params )
pyConverters: pname=None, params=<OpenGL.converters.CallFuncPyConverter object at 0x87f976c>
cConverters: pname=None, params=<OpenGL.converters.getPyArgsName object at 0x8b4cc84>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glGetIntegerv( GLenum(pname), arrays.GLintArray(params) ) -> None
glGetLightfv( light,pname,params )
pyConverters: light=None, pname=None, params=<OpenGL.converters.CallFuncPyConverter object at 0x87f9a2c>
cConverters: light=None, pname=None, params=<OpenGL.converters.getPyArgsName object at 0x8b4ccfc>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glGetLightfv( GLenum(light), GLenum(pname), arrays.GLfloatArray(params) ) -> None
glGetLightiv( light,pname,params )
pyConverters: light=None, pname=None, params=<OpenGL.converters.CallFuncPyConverter object at 0x87f932c>
cConverters: light=None, pname=None, params=<OpenGL.converters.getPyArgsName object at 0x8b4cd74>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glGetLightiv( GLenum(light), GLenum(pname), arrays.GLintArray(params) ) -> None
glGetMapdv( target,query,v )
pyConverters: target=None, query=None, v=<OpenGL.converters.CallFuncPyConverter object at 0x87f92ac>
cConverters: target=None, query=None, v=<OpenGL.converters.getPyArgsName object at 0x8b4cdec>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glGetMapdv( GLenum(target), GLenum(query), arrays.GLdoubleArray(v) ) -> None
glGetMapfv( target,query,v )
pyConverters: target=None, query=None, v=<OpenGL.converters.CallFuncPyConverter object at 0x87f92ec>
cConverters: target=None, query=None, v=<OpenGL.converters.getPyArgsName object at 0x8b4ce64>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glGetMapfv( GLenum(target), GLenum(query), arrays.GLfloatArray(v) ) -> None
glGetMapiv( target,query,v )
pyConverters: target=None, query=None, v=<OpenGL.converters.CallFuncPyConverter object at 0x87f93cc>
cConverters: target=None, query=None, v=<OpenGL.converters.getPyArgsName object at 0x8b4cedc>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glGetMapiv( GLenum(target), GLenum(query), arrays.GLintArray(v) ) -> None
glGetMaterialfv( face,pname,params )
pyConverters: face=None, pname=None, params=<OpenGL.converters.CallFuncPyConverter object at 0x87f910c>
cConverters: face=None, pname=None, params=<OpenGL.converters.getPyArgsName object at 0x8b4cf54>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glGetMaterialfv( GLenum(face), GLenum(pname), arrays.GLfloatArray(params) ) -> None
glGetMaterialiv( face,pname,params )
pyConverters: face=None, pname=None, params=<OpenGL.converters.CallFuncPyConverter object at 0x87f920c>
cConverters: face=None, pname=None, params=<OpenGL.converters.getPyArgsName object at 0x8b4cfcc>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glGetMaterialiv( GLenum(face), GLenum(pname), arrays.GLintArray(params) ) -> None
glGetPixelMapfv( map,values )
pyConverters: map=None, values=<OpenGL.converters.CallFuncPyConverter object at 0x87f9d6c>
cConverters: map=None, values=<OpenGL.converters.getPyArgsName object at 0x8b4f07c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glGetPixelMapfv( GLenum(map), arrays.GLfloatArray(values) ) -> None
glGetPixelMapuiv( map,values )
pyConverters: map=None, values=<OpenGL.converters.CallFuncPyConverter object at 0x87f96cc>
cConverters: map=None, values=<OpenGL.converters.getPyArgsName object at 0x8b4f0f4>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glGetPixelMapuiv( GLenum(map), arrays.GLuintArray(values) ) -> None
glGetPixelMapusv( map,values )
pyConverters: map=None, values=<OpenGL.converters.CallFuncPyConverter object at 0x87f94cc>
cConverters: map=None, values=<OpenGL.converters.getPyArgsName object at 0x8b4f16c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glGetPixelMapusv( GLenum(map), arrays.GLushortArray(values) ) -> None
glGetPolygonStipple( mask )
pyConverters: mask=<OpenGL.converters.CallFuncPyConverter object at 0x87f902c>
cConverters: mask=<OpenGL.converters.getPyArgsName object at 0x8b4f1e4>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glGetPolygonStipple( arrays.GLubyteArray(mask) ) -> None
glGetTexEnvfv( target,pname,params )
pyConverters: target=None, pname=None, params=<OpenGL.converters.CallFuncPyConverter object at 0x87f994c>
cConverters: target=None, pname=None, params=<OpenGL.converters.getPyArgsName object at 0x8b4f25c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glGetTexEnvfv( GLenum(target), GLenum(pname), arrays.GLfloatArray(params) ) -> None
glGetTexEnviv( target,pname,params )
pyConverters: target=None, pname=None, params=<OpenGL.converters.CallFuncPyConverter object at 0x87f952c>
cConverters: target=None, pname=None, params=<OpenGL.converters.getPyArgsName object at 0x8b4f2d4>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glGetTexEnviv( GLenum(target), GLenum(pname), arrays.GLintArray(params) ) -> None
glGetTexGendv( coord,pname,params )
pyConverters: coord=None, pname=None, params=<OpenGL.converters.CallFuncPyConverter object at 0x82ace4c>
cConverters: coord=None, pname=None, params=<OpenGL.converters.getPyArgsName object at 0x8b4f34c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glGetTexGendv( GLenum(coord), GLenum(pname), arrays.GLdoubleArray(params) ) -> None
glGetTexGenfv( coord,pname,params )
pyConverters: coord=None, pname=None, params=<OpenGL.converters.CallFuncPyConverter object at 0x82ac1cc>
cConverters: coord=None, pname=None, params=<OpenGL.converters.getPyArgsName object at 0x8b4f3c4>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glGetTexGenfv( GLenum(coord), GLenum(pname), arrays.GLfloatArray(params) ) -> None
glGetTexGeniv( coord,pname,params )
pyConverters: coord=None, pname=None, params=<OpenGL.converters.CallFuncPyConverter object at 0x82ac8ac>
cConverters: coord=None, pname=None, params=<OpenGL.converters.getPyArgsName object at 0x8b4f43c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glGetTexGeniv( GLenum(coord), GLenum(pname), arrays.GLintArray(params) ) -> None
glGetTexLevelParameterfv( target,level,pname,params )
pyConverters: target=None, level=None, pname=None, params=<OpenGL.converters.CallFuncPyConverter object at 0x82ac9ec>
cConverters: target=None, level=None, pname=None, params=<OpenGL.converters.getPyArgsName object at 0x8b4f4b4>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glGetTexLevelParameterfv( GLenum(target), GLint(level), GLenum(pname), arrays.GLfloatArray(params) ) -> None
glGetTexLevelParameteriv( target,level,pname,params )
pyConverters: target=None, level=None, pname=None, params=<OpenGL.converters.CallFuncPyConverter object at 0x82ac36c>
cConverters: target=None, level=None, pname=None, params=<OpenGL.converters.getPyArgsName object at 0x8b4f52c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glGetTexLevelParameteriv( GLenum(target), GLint(level), GLenum(pname), arrays.GLintArray(params) ) -> None
glGetTexParameterfv( target,pname,params )
pyConverters: target=None, pname=None, params=<OpenGL.converters.CallFuncPyConverter object at 0x82aceac>
cConverters: target=None, pname=None, params=<OpenGL.converters.getPyArgsName object at 0x8b4f5a4>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glGetTexParameterfv( GLenum(target), GLenum(pname), arrays.GLfloatArray(params) ) -> None
glGetTexParameteriv( target,pname,params )
pyConverters: target=None, pname=None, params=<OpenGL.converters.CallFuncPyConverter object at 0x82acf0c>
cConverters: target=None, pname=None, params=<OpenGL.converters.getPyArgsName object at 0x8b4f61c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glGetTexParameteriv( GLenum(target), GLenum(pname), arrays.GLintArray(params) ) -> None
glIndexdv( c )
pyConverters: c=<OpenGL.converters.CallFuncPyConverter object at 0x82ac2ac>
cConverters: c=<OpenGL.converters.getPyArgsName object at 0x8b4f694>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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
glIndexfv( c )
pyConverters: c=<OpenGL.converters.CallFuncPyConverter object at 0x82ac9cc>
cConverters: c=<OpenGL.converters.getPyArgsName object at 0x8b4f70c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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
glIndexiv( c )
pyConverters: c=<OpenGL.converters.CallFuncPyConverter object at 0x82acf8c>
cConverters: c=<OpenGL.converters.getPyArgsName object at 0x8b4f784>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glIndexiv( arrays.GLintArray(c) ) -> None
glIndexsv( c )
pyConverters: c=<OpenGL.converters.CallFuncPyConverter object at 0x82ac7cc>
cConverters: c=<OpenGL.converters.getPyArgsName object at 0x8b4f7fc>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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
glIndexubv( c )
pyConverters: c=<OpenGL.converters.CallFuncPyConverter object at 0x82ac78c>
cConverters: c=<OpenGL.converters.getPyArgsName object at 0x8b4f874>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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
glLightModelfv( pname,params )
pyConverters: pname=None, params=<OpenGL.converters.CallFuncPyConverter object at 0x82ac74c>
cConverters: pname=None, params=<OpenGL.converters.getPyArgsName object at 0x8b4f8ec>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glLightModelfv( GLenum(pname), arrays.GLfloatArray(params) ) -> None
glLightModeliv( pname,params )
pyConverters: pname=None, params=<OpenGL.converters.CallFuncPyConverter object at 0x82ac98c>
cConverters: pname=None, params=<OpenGL.converters.getPyArgsName object at 0x8b4f964>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glLightModeliv( GLenum(pname), arrays.GLintArray(params) ) -> None
glLightfv( light,pname,params )
pyConverters: light=None, pname=None, params=<OpenGL.converters.CallFuncPyConverter object at 0x82ac6ac>
cConverters: light=None, pname=None, params=<OpenGL.converters.getPyArgsName object at 0x8b4f9dc>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glLightfv( GLenum(light), GLenum(pname), arrays.GLfloatArray(params) ) -> None
glLightiv( light,pname,params )
pyConverters: light=None, pname=None, params=<OpenGL.converters.CallFuncPyConverter object at 0x82acf2c>
cConverters: light=None, pname=None, params=<OpenGL.converters.getPyArgsName object at 0x8b4fa54>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glLightiv( GLenum(light), GLenum(pname), arrays.GLintArray(params) ) -> None
glLoadMatrixd( m )
pyConverters: m=
asArraySize(incoming, function, args)
cConverters: m=<OpenGL.converters.getPyArgsName object at 0x8b4facc>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glLoadMatrixd( arrays.GLdoubleArray(m) ) -> None
glLoadMatrixf( m )
pyConverters: m=
asArraySize(incoming, function, args)
cConverters: m=<OpenGL.converters.getPyArgsName object at 0x8b4fb6c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glLoadMatrixf( arrays.GLfloatArray(m) ) -> None
glMap1d( target,u1,u2,stride,order,points )
pyConverters: target=None, u1=None, u2=None, stride=None, order=None, points=<OpenGL.converters.CallFuncPyConverter object at 0x824c64c>
cConverters: target=None, u1=None, u2=None, stride=None, order=None, points=<OpenGL.converters.getPyArgsName object at 0x8b4fc0c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glMap1d( GLenum(target), GLdouble(u1), GLdouble(u2), GLint(stride), GLint(order), arrays.GLdoubleArray(points) ) -> None
glMap1f( target,u1,u2,stride,order,points )
pyConverters: target=None, u1=None, u2=None, stride=None, order=None, points=<OpenGL.converters.CallFuncPyConverter object at 0x824c30c>
cConverters: target=None, u1=None, u2=None, stride=None, order=None, points=<OpenGL.converters.getPyArgsName object at 0x8b4fc84>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glMap1f( GLenum(target), GLfloat(u1), GLfloat(u2), GLint(stride), GLint(order), arrays.GLfloatArray(points) ) -> None
glMap2d( target,u1,u2,ustride,uorder,v1,v2,vstride,vorder,points )
pyConverters: target=None, u1=None, u2=None, ustride=None, uorder=None, v1=None, v2=None, vstride=None, vorder=None, points=<OpenGL.converters.CallFuncPyConverter object at 0x824c9ec>
cConverters: target=None, u1=None, u2=None, ustride=None, uorder=None, v1=None, v2=None, vstride=None, vorder=None, points=<OpenGL.converters.getPyArgsName object at 0x8b4fcfc>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glMap2d( GLenum(target), GLdouble(u1), GLdouble(u2), GLint(ustride), GLint(uorder), GLdouble(v1), GLdouble(v2), GLint(vstride), GLint(vorder), arrays.GLdoubleArray(points) ) -> None
glMap2f( target,u1,u2,ustride,uorder,v1,v2,vstride,vorder,points )
pyConverters: target=None, u1=None, u2=None, ustride=None, uorder=None, v1=None, v2=None, vstride=None, vorder=None, points=<OpenGL.converters.CallFuncPyConverter object at 0x824c6ac>
cConverters: target=None, u1=None, u2=None, ustride=None, uorder=None, v1=None, v2=None, vstride=None, vorder=None, points=<OpenGL.converters.getPyArgsName object at 0x8b4fd74>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glMap2f( GLenum(target), GLfloat(u1), GLfloat(u2), GLint(ustride), GLint(uorder), GLfloat(v1), GLfloat(v2), GLint(vstride), GLint(vorder), arrays.GLfloatArray(points) ) -> None
glMaterialfv( face,pname,params )
pyConverters: face=None, pname=None, params=<OpenGL.converters.CallFuncPyConverter object at 0x824cf6c>
cConverters: face=None, pname=None, params=<OpenGL.converters.getPyArgsName object at 0x8b4fdec>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glMaterialfv( GLenum(face), GLenum(pname), arrays.GLfloatArray(params) ) -> None
glMaterialiv( face,pname,params )
pyConverters: face=None, pname=None, params=<OpenGL.converters.CallFuncPyConverter object at 0x824cf0c>
cConverters: face=None, pname=None, params=<OpenGL.converters.getPyArgsName object at 0x8b4fe64>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glMaterialiv( GLenum(face), GLenum(pname), arrays.GLintArray(params) ) -> None
glMultMatrixd( m )
pyConverters: m=
asArraySize(incoming, function, args)
cConverters: m=<OpenGL.converters.getPyArgsName object at 0x8b4fedc>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glMultMatrixd( arrays.GLdoubleArray(m) ) -> None
glMultMatrixf( m )
pyConverters: m=
asArraySize(incoming, function, args)
cConverters: m=<OpenGL.converters.getPyArgsName object at 0x8b4ff7c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glMultMatrixf( arrays.GLfloatArray(m) ) -> None
glNormal3bv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b53054>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glNormal3bv( arrays.GLbyteArray(v) ) -> None
glNormal3dv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b530f4>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glNormal3dv( arrays.GLdoubleArray(v) ) -> None
glNormal3fv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b53194>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glNormal3fv( arrays.GLfloatArray(v) ) -> None
glNormal3iv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b53234>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glNormal3iv( arrays.GLintArray(v) ) -> None
glNormal3sv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b532d4>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glNormal3sv( arrays.GLshortArray(v) ) -> None
glPixelMapfv( map,mapsize,values )
pyConverters: map=None, mapsize=None, values=<OpenGL.converters.CallFuncPyConverter object at 0x824c28c>
cConverters: map=None, mapsize=None, values=<OpenGL.converters.getPyArgsName object at 0x8b53374>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glPixelMapfv( GLenum(map), GLsizei(mapsize), arrays.GLfloatArray(values) ) -> None
glPixelMapuiv( map,mapsize,values )
pyConverters: map=None, mapsize=None, values=<OpenGL.converters.CallFuncPyConverter object at 0x824c9ac>
cConverters: map=None, mapsize=None, values=<OpenGL.converters.getPyArgsName object at 0x8b533ec>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glPixelMapuiv( GLenum(map), GLsizei(mapsize), arrays.GLuintArray(values) ) -> None
glPixelMapusv( map,mapsize,values )
pyConverters: map=None, mapsize=None, values=<OpenGL.converters.CallFuncPyConverter object at 0x82b21cc>
cConverters: map=None, mapsize=None, values=<OpenGL.converters.getPyArgsName object at 0x8b53464>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glPixelMapusv( GLenum(map), GLsizei(mapsize), arrays.GLushortArray(values) ) -> None
glPolygonStipple( mask )
pyConverters: mask=<OpenGL.converters.CallFuncPyConverter object at 0x82b232c>
cConverters: mask=<OpenGL.converters.getPyArgsName object at 0x8b534dc>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glPolygonStipple( arrays.GLubyteArray(mask) ) -> None
glPrioritizeTextures( n,textures,priorities )
pyConverters: n=None, textures=<OpenGL.converters.CallFuncPyConverter object at 0x82b2ccc>, priorities=<OpenGL.converters.CallFuncPyConverter object at 0x82b262c>
cConverters: n=None, textures=<OpenGL.converters.getPyArgsName object at 0x8b53554>, priorities=<OpenGL.converters.getPyArgsName object at 0x8b535a4>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glPrioritizeTextures( GLsizei(n), arrays.GLuintArray(textures), arrays.GLclampfArray(priorities) ) -> None
glRasterPos2dv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b5361c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glRasterPos2dv( arrays.GLdoubleArray(v) ) -> None
glRasterPos2fv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b536bc>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glRasterPos2fv( arrays.GLfloatArray(v) ) -> None
glRasterPos2iv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b5375c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glRasterPos2iv( arrays.GLintArray(v) ) -> None
glRasterPos2sv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b537fc>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glRasterPos2sv( arrays.GLshortArray(v) ) -> None
glRasterPos3dv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b5389c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glRasterPos3dv( arrays.GLdoubleArray(v) ) -> None
glRasterPos3fv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b5393c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glRasterPos3fv( arrays.GLfloatArray(v) ) -> None
glRasterPos3iv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b539dc>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glRasterPos3iv( arrays.GLintArray(v) ) -> None
glRasterPos3sv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b53a7c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glRasterPos3sv( arrays.GLshortArray(v) ) -> None
glRasterPos4dv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b53b1c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glRasterPos4dv( arrays.GLdoubleArray(v) ) -> None
glRasterPos4fv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b53bbc>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glRasterPos4fv( arrays.GLfloatArray(v) ) -> None
glRasterPos4iv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b53c5c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glRasterPos4iv( arrays.GLintArray(v) ) -> None
glRasterPos4sv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b53cfc>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glRasterPos4sv( arrays.GLshortArray(v) ) -> None
glRectdv( v1,v2 )
pyConverters: v1=<OpenGL.converters.CallFuncPyConverter object at 0x82a1bcc>, v2=<OpenGL.converters.CallFuncPyConverter object at 0x82a1cac>
cConverters: v1=<OpenGL.converters.getPyArgsName object at 0x8b53d9c>, v2=<OpenGL.converters.getPyArgsName object at 0x8b53dec>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glRectdv( arrays.GLdoubleArray(v1), arrays.GLdoubleArray(v2) ) -> None
glRectfv( v1,v2 )
pyConverters: v1=<OpenGL.converters.CallFuncPyConverter object at 0x82a144c>, v2=<OpenGL.converters.CallFuncPyConverter object at 0x82a150c>
cConverters: v1=<OpenGL.converters.getPyArgsName object at 0x8b53e64>, v2=<OpenGL.converters.getPyArgsName object at 0x8b53eb4>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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
glRectiv( v1,v2 )
pyConverters: v1=<OpenGL.converters.CallFuncPyConverter object at 0x82a12ac>, v2=<OpenGL.converters.CallFuncPyConverter object at 0x82a156c>
cConverters: v1=<OpenGL.converters.getPyArgsName object at 0x8b53f2c>, v2=<OpenGL.converters.getPyArgsName object at 0x8b53f7c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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
glRectsv( v1,v2 )
pyConverters: v1=<OpenGL.converters.CallFuncPyConverter object at 0x82a1eec>, v2=<OpenGL.converters.CallFuncPyConverter object at 0x82a1fec>
cConverters: v1=<OpenGL.converters.getPyArgsName object at 0x8b5702c>, v2=<OpenGL.converters.getPyArgsName object at 0x8b5707c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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
glSelectBuffer( size,buffer )
pyConverters: size=None, buffer=<OpenGL.converters.CallFuncPyConverter object at 0x82a130c>
cConverters: size=None, buffer=<OpenGL.converters.getPyArgsName object at 0x8b570f4>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glSelectBuffer( GLsizei(size), arrays.GLuintArray(buffer) ) -> None
glTexCoord1dv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b5716c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glTexCoord1dv( arrays.GLdoubleArray(v) ) -> None
glTexCoord1fv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b5720c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glTexCoord1fv( arrays.GLfloatArray(v) ) -> None
glTexCoord1iv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b572ac>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glTexCoord1iv( arrays.GLintArray(v) ) -> None
glTexCoord1sv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b5734c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glTexCoord1sv( arrays.GLshortArray(v) ) -> None
glTexCoord2dv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b573ec>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glTexCoord2dv( arrays.GLdoubleArray(v) ) -> None
glTexCoord2fv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b5748c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glTexCoord2fv( arrays.GLfloatArray(v) ) -> None
glTexCoord2iv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b5752c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glTexCoord2iv( arrays.GLintArray(v) ) -> None
glTexCoord2sv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b575cc>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glTexCoord2sv( arrays.GLshortArray(v) ) -> None
glTexCoord3dv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b5766c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glTexCoord3dv( arrays.GLdoubleArray(v) ) -> None
glTexCoord3fv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b5770c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glTexCoord3fv( arrays.GLfloatArray(v) ) -> None
glTexCoord3iv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b577ac>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glTexCoord3iv( arrays.GLintArray(v) ) -> None
glTexCoord3sv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b5784c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glTexCoord3sv( arrays.GLshortArray(v) ) -> None
glTexCoord4dv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b578ec>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glTexCoord4dv( arrays.GLdoubleArray(v) ) -> None
glTexCoord4fv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b5798c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glTexCoord4fv( arrays.GLfloatArray(v) ) -> None
glTexCoord4iv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b57a2c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glTexCoord4iv( arrays.GLintArray(v) ) -> None
glTexCoord4sv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b57acc>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glTexCoord4sv( arrays.GLshortArray(v) ) -> None
glTexEnvfv( target,pname,params )
pyConverters: target=None, pname=None, params=<OpenGL.converters.CallFuncPyConverter object at 0x82b13ec>
cConverters: target=None, pname=None, params=<OpenGL.converters.getPyArgsName object at 0x8b57b6c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glTexEnvfv( GLenum(target), GLenum(pname), arrays.GLfloatArray(params) ) -> None
glTexEnviv( target,pname,params )
pyConverters: target=None, pname=None, params=<OpenGL.converters.CallFuncPyConverter object at 0x82b1a8c>
cConverters: target=None, pname=None, params=<OpenGL.converters.getPyArgsName object at 0x8b57be4>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glTexEnviv( GLenum(target), GLenum(pname), arrays.GLintArray(params) ) -> None
glTexGendv( coord,pname,params )
pyConverters: coord=None, pname=None, params=<OpenGL.converters.CallFuncPyConverter object at 0x82b1bac>
cConverters: coord=None, pname=None, params=<OpenGL.converters.getPyArgsName object at 0x8b57c5c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glTexGendv( GLenum(coord), GLenum(pname), arrays.GLdoubleArray(params) ) -> None
glTexGenfv( coord,pname,params )
pyConverters: coord=None, pname=None, params=<OpenGL.converters.CallFuncPyConverter object at 0x82b12ec>
cConverters: coord=None, pname=None, params=<OpenGL.converters.getPyArgsName object at 0x8b57cd4>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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
glTexGeniv( coord,pname,params )
pyConverters: coord=None, pname=None, params=<OpenGL.converters.CallFuncPyConverter object at 0x82b116c>
cConverters: coord=None, pname=None, params=<OpenGL.converters.getPyArgsName object at 0x8b57d4c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glTexGeniv( GLenum(coord), GLenum(pname), arrays.GLintArray(params) ) -> None
glTexParameterfv( target,pname,params )
pyConverters: target=None, pname=None, params=<OpenGL.converters.CallFuncPyConverter object at 0x82b1eec>
cConverters: target=None, pname=None, params=<OpenGL.converters.getPyArgsName object at 0x8b57dc4>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glTexParameterfv( GLenum(target), GLenum(pname), arrays.GLfloatArray(params) ) -> None
glTexParameteriv( target,pname,params )
pyConverters: target=None, pname=None, params=<OpenGL.converters.CallFuncPyConverter object at 0x82b102c>
cConverters: target=None, pname=None, params=<OpenGL.converters.getPyArgsName object at 0x8b57e3c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glTexParameteriv( GLenum(target), GLenum(pname), arrays.GLintArray(params) ) -> None
glVertex2dv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b57eb4>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glVertex2dv( arrays.GLdoubleArray(v) ) -> None
glVertex2fv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b57f54>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glVertex2fv( arrays.GLfloatArray(v) ) -> None
glVertex2iv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b5a02c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glVertex2iv( arrays.GLintArray(v) ) -> None
glVertex2sv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b5a0cc>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glVertex2sv( arrays.GLshortArray(v) ) -> None
glVertex3dv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b5a16c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glVertex3dv( arrays.GLdoubleArray(v) ) -> None
glVertex3fv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b5a20c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glVertex3fv( arrays.GLfloatArray(v) ) -> None
glVertex3iv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b5a2ac>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glVertex3iv( arrays.GLintArray(v) ) -> None
glVertex3sv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b5a34c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glVertex3sv( arrays.GLshortArray(v) ) -> None
glVertex4dv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b5a3ec>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glVertex4dv( arrays.GLdoubleArray(v) ) -> None
glVertex4fv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b5a48c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glVertex4fv( arrays.GLfloatArray(v) ) -> None
glVertex4iv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b5a52c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glVertex4iv( arrays.GLintArray(v) ) -> None
glVertex4sv( v )
pyConverters: v=
asArraySize(incoming, function, args)
cConverters: v=<OpenGL.converters.getPyArgsName object at 0x8b5a5cc>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glVertex4sv( arrays.GLshortArray(v) ) -> None
memmove = <CFunctionType object at 0x4022bf9c> memset = <CFunctionType object at 0x835202c>
resize(...)
Resize the memory buffer of a ctypes instance
set_conversion_mode(...)
set_conversion_mode(encoding, errors) -> (previous-encoding, previous-errors)
 
Set the encoding and error handling ctypes uses when converting
between unicode and strings.  Returns the previous values.
sizeof(...)
sizeof(C type) -> integer
sizeof(C instance) -> integer
Return the size in bytes of a C instance

 
Data
        DEFAULT_MODE = 0
GLvoid = None
RTLD_GLOBAL = 256
RTLD_LOCAL = 0
__all__ = ['glAreTexturesResident', 'glBitmap', 'glClipPlane', 'glColor3bv', 'glColor3dv', 'glColor3fv', 'glColor3iv', 'glColor3sv', 'glColor3ubv', 'glColor3uiv', 'glColor3usv', 'glColor4bv', 'glColor4dv', 'glColor4fv', 'glColor4iv', 'glColor4sv', 'glColor4ubv', 'glColor4uiv', 'glColor4usv', 'glDeleteTextures', ...]
__file__ = '/build/buildd/pyopengl-3.0.0~b3/OpenGL/raw/GL/annotations.py'
__name__ = 'OpenGL.raw.GL.annotations'
cdll = <ctypes.LibraryLoader object at 0x835146c>
pydll = <ctypes.LibraryLoader object at 0x835148c>
pythonapi = <PyDLL 'None', handle 4001c668 at 83514ac>