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