OpenGL.raw.GL.annotations
index
/build/buildd/pyopengl-3.0.0~b6/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 0x829cecc>, residences=None
cConverters: n=None, textures=<OpenGL.converters.getPyArgsName object at 0x873dc34>, 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 0x87a5bec>
cConverters: width=None, height=None, xorig=None, yorig=None, xmove=None, ymove=None, bitmap=<OpenGL.converters.getPyArgsName object at 0x873dcac>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x87a528c>
cConverters: plane=None, equation=<OpenGL.converters.getPyArgsName object at 0x873dd24>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x873dd9c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x873de3c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x873dedc>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x873df7c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x822f054>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x822f0f4>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x822f194>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x822f234>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x822f2d4>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x822f374>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x822f414>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x822f4b4>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x822f554>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x822f5f4>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x822f694>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x822f734>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x82c32ec>
cConverters: n=None, textures=<OpenGL.converters.getPyArgsName object at 0x822f7d4>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x822f84c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x822f8ec>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x822f98c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x822fa2c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x82c3eec>
cConverters: size=None, type=None, buffer=<OpenGL.converters.getPyArgsName object at 0x822facc>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x82c328c>
cConverters: pname=None, params=<OpenGL.converters.getPyArgsName object at 0x822fb44>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x82c37cc>
cConverters: pname=None, params=<OpenGL.converters.getPyArgsName object at 0x822fbbc>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x82c332c>
cConverters: n=None, textures=<OpenGL.converters.getPyArgsName object at 0x822fc34>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x82c39ac>
cConverters: plane=None, equation=<OpenGL.converters.getPyArgsName object at 0x822fcac>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x82c338c>
cConverters: pname=None, params=<OpenGL.converters.getPyArgsName object at 0x822fd24>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x82c356c>
cConverters: pname=None, params=<OpenGL.converters.getPyArgsName object at 0x822fd9c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x82c3bcc>
cConverters: pname=None, params=<OpenGL.converters.getPyArgsName object at 0x822fe14>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x82c39ec>
cConverters: light=None, pname=None, params=<OpenGL.converters.getPyArgsName object at 0x822fe8c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x82c35ec>
cConverters: light=None, pname=None, params=<OpenGL.converters.getPyArgsName object at 0x822ff04>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x82c3d6c>
cConverters: target=None, query=None, v=<OpenGL.converters.getPyArgsName object at 0x822ff7c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x82c3c6c>
cConverters: target=None, query=None, v=<OpenGL.converters.getPyArgsName object at 0x823402c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x82c30ec>
cConverters: target=None, query=None, v=<OpenGL.converters.getPyArgsName object at 0x82340a4>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x879c72c>
cConverters: face=None, pname=None, params=<OpenGL.converters.getPyArgsName object at 0x823411c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x879c16c>
cConverters: face=None, pname=None, params=<OpenGL.converters.getPyArgsName object at 0x8234194>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x879ca0c>
cConverters: map=None, values=<OpenGL.converters.getPyArgsName object at 0x823420c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x879ccec>
cConverters: map=None, values=<OpenGL.converters.getPyArgsName object at 0x8234284>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x879c2cc>
cConverters: map=None, values=<OpenGL.converters.getPyArgsName object at 0x82342fc>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x879cf8c>
cConverters: mask=<OpenGL.converters.getPyArgsName object at 0x8234374>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x879c8ec>
cConverters: target=None, pname=None, params=<OpenGL.converters.getPyArgsName object at 0x82343ec>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x879ca8c>
cConverters: target=None, pname=None, params=<OpenGL.converters.getPyArgsName object at 0x8234464>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x879c12c>
cConverters: coord=None, pname=None, params=<OpenGL.converters.getPyArgsName object at 0x82344dc>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x879c94c>
cConverters: coord=None, pname=None, params=<OpenGL.converters.getPyArgsName object at 0x8234554>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x879cd2c>
cConverters: coord=None, pname=None, params=<OpenGL.converters.getPyArgsName object at 0x82345cc>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x879c80c>
cConverters: target=None, level=None, pname=None, params=<OpenGL.converters.getPyArgsName object at 0x8234644>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x879c50c>
cConverters: target=None, level=None, pname=None, params=<OpenGL.converters.getPyArgsName object at 0x82346bc>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x879c7cc>
cConverters: target=None, pname=None, params=<OpenGL.converters.getPyArgsName object at 0x8234734>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x879c9ac>
cConverters: target=None, pname=None, params=<OpenGL.converters.getPyArgsName object at 0x82347ac>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x87aae0c>
cConverters: c=<OpenGL.converters.getPyArgsName object at 0x8234824>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x87aa2cc>
cConverters: c=<OpenGL.converters.getPyArgsName object at 0x823489c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x87aac6c>
cConverters: c=<OpenGL.converters.getPyArgsName object at 0x8234914>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x87aa34c>
cConverters: c=<OpenGL.converters.getPyArgsName object at 0x823498c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x87aa18c>
cConverters: c=<OpenGL.converters.getPyArgsName object at 0x8234a04>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x87aa5ac>
cConverters: pname=None, params=<OpenGL.converters.getPyArgsName object at 0x8234a7c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x87aac0c>
cConverters: pname=None, params=<OpenGL.converters.getPyArgsName object at 0x8234af4>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x87aaa8c>
cConverters: light=None, pname=None, params=<OpenGL.converters.getPyArgsName object at 0x8234b6c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x87aa70c>
cConverters: light=None, pname=None, params=<OpenGL.converters.getPyArgsName object at 0x8234be4>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x8234c5c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x8234cfc>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x87aaeac>
cConverters: target=None, u1=None, u2=None, stride=None, order=None, points=<OpenGL.converters.getPyArgsName object at 0x8234d9c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x87aa2ac>
cConverters: target=None, u1=None, u2=None, stride=None, order=None, points=<OpenGL.converters.getPyArgsName object at 0x8234e14>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x87aa7ec>
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 0x8234e8c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x87aacac>
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 0x8234f04>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x87aafcc>
cConverters: face=None, pname=None, params=<OpenGL.converters.getPyArgsName object at 0x8234f7c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x875526c>
cConverters: face=None, pname=None, params=<OpenGL.converters.getPyArgsName object at 0x823802c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x82380a4>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x8238144>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x82381e4>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x8238284>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x8238324>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x82383c4>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x8238464>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x875548c>
cConverters: map=None, mapsize=None, values=<OpenGL.converters.getPyArgsName object at 0x8238504>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x8797d4c>
cConverters: map=None, mapsize=None, values=<OpenGL.converters.getPyArgsName object at 0x823857c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x87977ec>
cConverters: map=None, mapsize=None, values=<OpenGL.converters.getPyArgsName object at 0x82385f4>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x87970ac>
cConverters: mask=<OpenGL.converters.getPyArgsName object at 0x823866c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x879734c>, priorities=<OpenGL.converters.CallFuncPyConverter object at 0x8797b6c>
cConverters: n=None, textures=<OpenGL.converters.getPyArgsName object at 0x82386e4>, priorities=<OpenGL.converters.getPyArgsName object at 0x8238734>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x82387ac>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x823884c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x82388ec>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x823898c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x8238a2c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x8238acc>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x8238b6c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x8238c0c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x8238cac>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x8238d4c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x8238dec>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x8238e8c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x87523cc>, v2=<OpenGL.converters.CallFuncPyConverter object at 0x875226c>
cConverters: v1=<OpenGL.converters.getPyArgsName object at 0x8238f2c>, v2=<OpenGL.converters.getPyArgsName object at 0x8238f7c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x87520ac>, v2=<OpenGL.converters.CallFuncPyConverter object at 0x875286c>
cConverters: v1=<OpenGL.converters.getPyArgsName object at 0x823b02c>, v2=<OpenGL.converters.getPyArgsName object at 0x823b07c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x875240c>, v2=<OpenGL.converters.CallFuncPyConverter object at 0x8752b4c>
cConverters: v1=<OpenGL.converters.getPyArgsName object at 0x823b0f4>, v2=<OpenGL.converters.getPyArgsName object at 0x823b144>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x87527ac>, v2=<OpenGL.converters.CallFuncPyConverter object at 0x875218c>
cConverters: v1=<OpenGL.converters.getPyArgsName object at 0x823b1bc>, v2=<OpenGL.converters.getPyArgsName object at 0x823b20c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x8752f2c>
cConverters: size=None, buffer=<OpenGL.converters.getPyArgsName object at 0x823b284>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x823b2fc>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x823b39c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x823b43c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x823b4dc>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x823b57c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x823b61c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x823b6bc>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x823b75c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x823b7fc>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x823b89c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x823b93c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x823b9dc>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x823ba7c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x823bb1c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x823bbbc>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x823bc5c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x879590c>
cConverters: target=None, pname=None, params=<OpenGL.converters.getPyArgsName object at 0x823bcfc>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x821d3cc>
cConverters: target=None, pname=None, params=<OpenGL.converters.getPyArgsName object at 0x823bd74>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x821dc4c>
cConverters: coord=None, pname=None, params=<OpenGL.converters.getPyArgsName object at 0x823bdec>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x821d04c>
cConverters: coord=None, pname=None, params=<OpenGL.converters.getPyArgsName object at 0x823be64>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x821d10c>
cConverters: coord=None, pname=None, params=<OpenGL.converters.getPyArgsName object at 0x823bedc>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x821dc8c>
cConverters: target=None, pname=None, params=<OpenGL.converters.getPyArgsName object at 0x823bf54>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x821d9ec>
cConverters: target=None, pname=None, params=<OpenGL.converters.getPyArgsName object at 0x823bfcc>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x823f07c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x823f11c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x823f1bc>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x823f25c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x823f2fc>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x823f39c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x823f43c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x823f4dc>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x823f57c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x823f61c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x823f6bc>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x823f75c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x835602c> memset = <CFunctionType object at 0x8356094>
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~b6/OpenGL/raw/GL/annotations.py'
__name__ = 'OpenGL.raw.GL.annotations'
cdll = <ctypes.LibraryLoader object at 0x8353a2c>
pydll = <ctypes.LibraryLoader object at 0x8353a4c>
pythonapi = <PyDLL 'None', handle 4001d670 at 8353a6c>