| |
- 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 )
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 )
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 )
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 )
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 )
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 )
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 )
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 )
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 )
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 )
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 )
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 )
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 )
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 )
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 )
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 )
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 )
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 )
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 )
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 )
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 )
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 )
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 )
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 )
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 )
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 )
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 )
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 )
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 )
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 )
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 )
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 )
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 )
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 )
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 )
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 )
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 )
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 )
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 )
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 )
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 )
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 )
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 )
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 )
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 )
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 )
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 )
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 )
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 )
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 )
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 )
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 )
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 )
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 )
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 )
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 )
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 )
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 )
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 )
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 )
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 )
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 )
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 )
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 )
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 )
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 )
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 )
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 )
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 )
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
|