OpenGL.GL.simple | index /oldroot/var/pylive/src/OpenGL-dev/OpenGL-ctypes/OpenGL/GL/simple.py

`# generated by 'xml2py'
# flags 'gl.xml -kfed -l libGL.so -o simple.py'`

Modules
`` |  |
OpenGL.constants | OpenGL.arrays | ctypes | OpenGL.platform

Functions
> `` |  | glAccum(...) `glAccum( GLenum(op), GLfloat(value) ) -> None` glActiveTexture(...) `glActiveTexture( GLenum(texture) ) -> None` glActiveTextureARB(...) `glActiveTextureARB( GLenum(texture) ) -> None` glAlphaFunc(...) `glAlphaFunc( GLenum(func), GLclampf(ref) ) -> None` glAreTexturesResident( n,textures,residences ) pyConverters: n=None, textures=<OpenGL.converters.CallFuncPyConverter object>, residences=None cConverters: n=None, textures=<OpenGL.converters.getPyArgsName object>, residences=None cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glAreTexturesResident( GLsizei(n), arrays.GLuintArray(textures), ctypes.POINTER(GLboolean)(residences) ) -> GLboolean
> glArrayElement(...) `glArrayElement( GLint(i) ) -> None` glBegin(...) `glBegin( GLenum(mode) ) -> None` glBindTexture(...) `glBindTexture( GLenum(target), GLuint(texture) ) -> None` glBitmap( width,height,xorig,yorig,xmove,ymove,bitmap ) pyConverters: width=None, height=None, xorig=None, yorig=None, xmove=None, ymove=None, bitmap=<OpenGL.converters.CallFuncPyConverter object> cConverters: width=None, height=None, xorig=None, yorig=None, xmove=None, ymove=None, bitmap=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glBitmap( GLsizei(width), GLsizei(height), GLfloat(xorig), GLfloat(yorig), GLfloat(xmove), GLfloat(ymove), arrays.GLubyteArray(bitmap) ) -> None
> glBlendColor(...) `glBlendColor( GLclampf(red), GLclampf(green), GLclampf(blue), GLclampf(alpha) ) -> None` glBlendEquation(...) `glBlendEquation( GLenum(mode) ) -> None` glBlendFunc(...) `glBlendFunc( GLenum(sfactor), GLenum(dfactor) ) -> None` glCallList(...) `glCallList( GLuint(list) ) -> None` glCallLists(...) `glCallLists( GLsizei(n), GLenum(type), ctypes.POINTER(GLvoid)(lists) ) -> None` glClear(...) `glClear( GLbitfield(mask) ) -> None` glClearAccum(...) `glClearAccum( GLfloat(red), GLfloat(green), GLfloat(blue), GLfloat(alpha) ) -> None` glClearColor(...) `glClearColor( GLclampf(red), GLclampf(green), GLclampf(blue), GLclampf(alpha) ) -> None` glClearDepth(...) `glClearDepth( GLclampd(depth) ) -> None` glClearIndex(...) `glClearIndex( GLfloat(c) ) -> None` glClearStencil(...) `glClearStencil( GLint(s) ) -> None` glClientActiveTexture(...) `glClientActiveTexture( GLenum(texture) ) -> None` glClientActiveTextureARB(...) `glClientActiveTextureARB( GLenum(texture) ) -> None` glClipPlane( plane,equation ) pyConverters: plane=None, equation=<OpenGL.converters.CallFuncPyConverter object> cConverters: plane=None, equation=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glClipPlane( GLenum(plane), arrays.GLdoubleArray(equation) ) -> None
> glColor3b(...) `glColor3b( GLbyte(red), GLbyte(green), GLbyte(blue) ) -> None` glColor3bv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glColor3bv( arrays.GLbyteArray(v) ) -> None
> glColor3d(...) `glColor3d( GLdouble(red), GLdouble(green), GLdouble(blue) ) -> None` glColor3dv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glColor3dv( arrays.GLdoubleArray(v) ) -> None
> glColor3f(...) `glColor3f( GLfloat(red), GLfloat(green), GLfloat(blue) ) -> None` glColor3fv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glColor3fv( arrays.GLfloatArray(v) ) -> None
> glColor3i(...) `glColor3i( GLint(red), GLint(green), GLint(blue) ) -> None` glColor3iv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glColor3iv( arrays.GLintArray(v) ) -> None
> glColor3s(...) `glColor3s( GLshort(red), GLshort(green), GLshort(blue) ) -> None` glColor3sv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glColor3sv( arrays.GLshortArray(v) ) -> None
> glColor3ub(...) `glColor3ub( GLubyte(red), GLubyte(green), GLubyte(blue) ) -> None` glColor3ubv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glColor3ubv( arrays.GLubyteArray(v) ) -> None
> glColor3ui(...) `glColor3ui( GLuint(red), GLuint(green), GLuint(blue) ) -> None` glColor3uiv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glColor3uiv( arrays.GLuintArray(v) ) -> None
> glColor3us(...) `glColor3us( GLushort(red), GLushort(green), GLushort(blue) ) -> None` glColor3usv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glColor3usv( arrays.GLushortArray(v) ) -> None
> glColor4b(...) `glColor4b( GLbyte(red), GLbyte(green), GLbyte(blue), GLbyte(alpha) ) -> None` glColor4bv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glColor4bv( arrays.GLbyteArray(v) ) -> None
> glColor4d(...) `glColor4d( GLdouble(red), GLdouble(green), GLdouble(blue), GLdouble(alpha) ) -> None` glColor4dv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glColor4dv( arrays.GLdoubleArray(v) ) -> None
> glColor4f(...) `glColor4f( GLfloat(red), GLfloat(green), GLfloat(blue), GLfloat(alpha) ) -> None` glColor4fv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glColor4fv( arrays.GLfloatArray(v) ) -> None
> glColor4i(...) `glColor4i( GLint(red), GLint(green), GLint(blue), GLint(alpha) ) -> None` glColor4iv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glColor4iv( arrays.GLintArray(v) ) -> None
> glColor4s(...) `glColor4s( GLshort(red), GLshort(green), GLshort(blue), GLshort(alpha) ) -> None` glColor4sv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glColor4sv( arrays.GLshortArray(v) ) -> None
> glColor4ub(...) `glColor4ub( GLubyte(red), GLubyte(green), GLubyte(blue), GLubyte(alpha) ) -> None` glColor4ubv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glColor4ubv( arrays.GLubyteArray(v) ) -> None
> glColor4ui(...) `glColor4ui( GLuint(red), GLuint(green), GLuint(blue), GLuint(alpha) ) -> None` glColor4uiv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glColor4uiv( arrays.GLuintArray(v) ) -> None
> glColor4us(...) `glColor4us( GLushort(red), GLushort(green), GLushort(blue), GLushort(alpha) ) -> None` glColor4usv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glColor4usv( arrays.GLushortArray(v) ) -> None
> glColorMask(...) `glColorMask( GLboolean(red), GLboolean(green), GLboolean(blue), GLboolean(alpha) ) -> None` glColorMaterial(...) `glColorMaterial( GLenum(face), GLenum(mode) ) -> None` glColorPointer(...) `glColorPointer( GLint(size), GLenum(type), GLsizei(stride), ctypes.POINTER(GLvoid)(ptr) ) -> None` glColorSubTable(...) `glColorSubTable( GLenum(target), GLsizei(start), GLsizei(count), GLenum(format), GLenum(type), ctypes.POINTER(GLvoid)(data) ) -> None` glColorTable(...) `glColorTable( GLenum(target), GLenum(internalformat), GLsizei(width), GLenum(format), GLenum(type), ctypes.POINTER(GLvoid)(table) ) -> None` glColorTableParameterfv( target,pname,params ) pyConverters: target=None, pname=None, params= asArraySize(incoming, function, args) cConverters: target=None, pname=None, params=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glColorTableParameterfv( GLenum(target), GLenum(pname), arrays.GLfloatArray(params) ) -> None
> glColorTableParameteriv( target,pname,params ) pyConverters: target=None, pname=None, params=<OpenGL.converters.CallFuncPyConverter object> cConverters: target=None, pname=None, params=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glColorTableParameteriv( GLenum(target), GLenum(pname), arrays.GLintArray(params) ) -> None
> glCompressedTexImage1D(...) `glCompressedTexImage1D( GLenum(target), GLint(level), GLenum(internalformat), GLsizei(width), GLint(border), GLsizei(imageSize), ctypes.POINTER(GLvoid)(data) ) -> None` glCompressedTexImage2D(...) `glCompressedTexImage2D( GLenum(target), GLint(level), GLenum(internalformat), GLsizei(width), GLsizei(height), GLint(border), GLsizei(imageSize), ctypes.POINTER(GLvoid)(data) ) -> None` glCompressedTexImage3D(...) `glCompressedTexImage3D( GLenum(target), GLint(level), GLenum(internalformat), GLsizei(width), GLsizei(height), GLsizei(depth), GLint(border), GLsizei(imageSize), ctypes.POINTER(GLvoid)(data) ) -> None` glCompressedTexSubImage1D(...) `glCompressedTexSubImage1D( GLenum(target), GLint(level), GLint(xoffset), GLsizei(width), GLenum(format), GLsizei(imageSize), ctypes.POINTER(GLvoid)(data) ) -> None` glCompressedTexSubImage2D(...) `glCompressedTexSubImage2D( GLenum(target), GLint(level), GLint(xoffset), GLint(yoffset), GLsizei(width), GLsizei(height), GLenum(format), GLsizei(imageSize), ctypes.POINTER(GLvoid)(data) ) -> None` glCompressedTexSubImage3D(...) `glCompressedTexSubImage3D( GLenum(target), GLint(level), GLint(xoffset), GLint(yoffset), GLint(zoffset), GLsizei(width), GLsizei(height), GLsizei(depth), GLenum(format), GLsizei(imageSize), ctypes.POINTER(GLvoid)(data) ) -> None` glConvolutionFilter1D(...) `glConvolutionFilter1D( GLenum(target), GLenum(internalformat), GLsizei(width), GLenum(format), GLenum(type), ctypes.POINTER(GLvoid)(image) ) -> None` glConvolutionFilter2D(...) `glConvolutionFilter2D( GLenum(target), GLenum(internalformat), GLsizei(width), GLsizei(height), GLenum(format), GLenum(type), ctypes.POINTER(GLvoid)(image) ) -> None` glConvolutionParameterf(...) `glConvolutionParameterf( GLenum(target), GLenum(pname), GLfloat(params) ) -> None` glConvolutionParameterfv( target,pname,params ) pyConverters: target=None, pname=None, params=<OpenGL.converters.CallFuncPyConverter object> cConverters: target=None, pname=None, params=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glConvolutionParameterfv( GLenum(target), GLenum(pname), arrays.GLfloatArray(params) ) -> None
> glConvolutionParameteri(...) `glConvolutionParameteri( GLenum(target), GLenum(pname), GLint(params) ) -> None` glConvolutionParameteriv( target,pname,params ) pyConverters: target=None, pname=None, params=<OpenGL.converters.CallFuncPyConverter object> cConverters: target=None, pname=None, params=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glConvolutionParameteriv( GLenum(target), GLenum(pname), arrays.GLintArray(params) ) -> None
> glCopyColorSubTable(...) `glCopyColorSubTable( GLenum(target), GLsizei(start), GLint(x), GLint(y), GLsizei(width) ) -> None` glCopyColorTable(...) `glCopyColorTable( GLenum(target), GLenum(internalformat), GLint(x), GLint(y), GLsizei(width) ) -> None` glCopyConvolutionFilter1D(...) `glCopyConvolutionFilter1D( GLenum(target), GLenum(internalformat), GLint(x), GLint(y), GLsizei(width) ) -> None` glCopyConvolutionFilter2D(...) `glCopyConvolutionFilter2D( GLenum(target), GLenum(internalformat), GLint(x), GLint(y), GLsizei(width), GLsizei(height) ) -> None` glCopyPixels(...) `glCopyPixels( GLint(x), GLint(y), GLsizei(width), GLsizei(height), GLenum(type) ) -> None` glCopyTexImage1D(...) `glCopyTexImage1D( GLenum(target), GLint(level), GLenum(internalformat), GLint(x), GLint(y), GLsizei(width), GLint(border) ) -> None` glCopyTexImage2D(...) `glCopyTexImage2D( GLenum(target), GLint(level), GLenum(internalformat), GLint(x), GLint(y), GLsizei(width), GLsizei(height), GLint(border) ) -> None` glCopyTexSubImage1D(...) `glCopyTexSubImage1D( GLenum(target), GLint(level), GLint(xoffset), GLint(x), GLint(y), GLsizei(width) ) -> None` glCopyTexSubImage2D(...) `glCopyTexSubImage2D( GLenum(target), GLint(level), GLint(xoffset), GLint(yoffset), GLint(x), GLint(y), GLsizei(width), GLsizei(height) ) -> None` glCopyTexSubImage3D(...) `glCopyTexSubImage3D( GLenum(target), GLint(level), GLint(xoffset), GLint(yoffset), GLint(zoffset), GLint(x), GLint(y), GLsizei(width), GLsizei(height) ) -> None` glCullFace(...) `glCullFace( GLenum(mode) ) -> None` glDeleteLists(...) `glDeleteLists( GLuint(list), GLsizei(range) ) -> None` glDeleteTextures( n,textures ) pyConverters: n=None, textures=<OpenGL.converters.CallFuncPyConverter object> cConverters: n=None, textures=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glDeleteTextures( GLsizei(n), arrays.GLuintArray(textures) ) -> None
> glDepthFunc(...) `glDepthFunc( GLenum(func) ) -> None` glDepthMask(...) `glDepthMask( GLboolean(flag) ) -> None` glDepthRange(...) `glDepthRange( GLclampd(near_val), GLclampd(far_val) ) -> None` glDisable(...) `glDisable( GLenum(cap) ) -> None` glDisableClientState(...) `glDisableClientState( GLenum(cap) ) -> None` glDrawArrays(...) `glDrawArrays( GLenum(mode), GLint(first), GLsizei(count) ) -> None` glDrawBuffer(...) `glDrawBuffer( GLenum(mode) ) -> None` glDrawElements(...) `glDrawElements( GLenum(mode), GLsizei(count), GLenum(type), ctypes.POINTER(GLvoid)(indices) ) -> None` glDrawPixels(...) `glDrawPixels( GLsizei(width), GLsizei(height), GLenum(format), GLenum(type), ctypes.POINTER(GLvoid)(pixels) ) -> None` glDrawRangeElements(...) `glDrawRangeElements( GLenum(mode), GLuint(start), GLuint(end), GLsizei(count), GLenum(type), ctypes.POINTER(GLvoid)(indices) ) -> None` glEdgeFlag(...) `glEdgeFlag( GLboolean(flag) ) -> None` glEdgeFlagPointer(...) `glEdgeFlagPointer( GLsizei(stride), ctypes.POINTER(GLvoid)(ptr) ) -> None` glEdgeFlagv(...) `glEdgeFlagv( ctypes.POINTER(GLboolean)(flag) ) -> None` glEnable(...) `glEnable( GLenum(cap) ) -> None` glEnableClientState(...) `glEnableClientState( GLenum(cap) ) -> None` glEnd(...) `glEnd( ) -> None` glEndList(...) `glEndList( ) -> None` glEvalCoord1d(...) `glEvalCoord1d( GLdouble(u) ) -> None` glEvalCoord1dv( u ) pyConverters: u= asArraySize(incoming, function, args) cConverters: u=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glEvalCoord1dv( arrays.GLdoubleArray(u) ) -> None
> glEvalCoord1f(...) `glEvalCoord1f( GLfloat(u) ) -> None` glEvalCoord1fv( u ) pyConverters: u= asArraySize(incoming, function, args) cConverters: u=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glEvalCoord1fv( arrays.GLfloatArray(u) ) -> None
> glEvalCoord2d(...) `glEvalCoord2d( GLdouble(u), GLdouble(v) ) -> None` glEvalCoord2dv( u ) pyConverters: u= asArraySize(incoming, function, args) cConverters: u=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glEvalCoord2dv( arrays.GLdoubleArray(u) ) -> None
> glEvalCoord2f(...) `glEvalCoord2f( GLfloat(u), GLfloat(v) ) -> None` glEvalCoord2fv( u ) pyConverters: u= asArraySize(incoming, function, args) cConverters: u=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glEvalCoord2fv( arrays.GLfloatArray(u) ) -> None
> glEvalMesh1(...) `glEvalMesh1( GLenum(mode), GLint(i1), GLint(i2) ) -> None` glEvalMesh2(...) `glEvalMesh2( GLenum(mode), GLint(i1), GLint(i2), GLint(j1), GLint(j2) ) -> None` glEvalPoint1(...) `glEvalPoint1( GLint(i) ) -> None` glEvalPoint2(...) `glEvalPoint2( GLint(i), GLint(j) ) -> None` glFeedbackBuffer( size,type,buffer ) pyConverters: size=None, type=None, buffer=<OpenGL.converters.CallFuncPyConverter object> cConverters: size=None, type=None, buffer=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glFeedbackBuffer( GLsizei(size), GLenum(type), arrays.GLfloatArray(buffer) ) -> None
> glFinish(...) `glFinish( ) -> None` glFlush(...) `glFlush( ) -> None` glFogf(...) `glFogf( GLenum(pname), GLfloat(param) ) -> None` glFogfv( pname,params ) pyConverters: pname=None, params=<OpenGL.converters.CallFuncPyConverter object> cConverters: pname=None, params=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glFogfv( GLenum(pname), arrays.GLfloatArray(params) ) -> None
> glFogi(...) `glFogi( GLenum(pname), GLint(param) ) -> None` glFogiv( pname,params ) pyConverters: pname=None, params=<OpenGL.converters.CallFuncPyConverter object> cConverters: pname=None, params=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glFogiv( GLenum(pname), arrays.GLintArray(params) ) -> None
> glFrontFace(...) `glFrontFace( GLenum(mode) ) -> None` glFrustum(...) `glFrustum( GLdouble(left), GLdouble(right), GLdouble(bottom), GLdouble(top), GLdouble(near_val), GLdouble(far_val) ) -> None` glGenLists(...) `glGenLists( GLsizei(range) ) -> GLuint` glGenTextures( n,textures ) pyConverters: n=None, textures=<OpenGL.converters.CallFuncPyConverter object> cConverters: n=None, textures=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glGenTextures( GLsizei(n), arrays.GLuintArray(textures) ) -> None
> glGetBooleanv(...) `glGetBooleanv( GLenum(pname), ctypes.POINTER(GLboolean)(params) ) -> None` glGetClipPlane(...) `glGetClipPlane( GLenum(plane), arrays.GLdoubleArray(equation) ) -> None` glGetColorTable(...) `glGetColorTable( GLenum(target), GLenum(format), GLenum(type), ctypes.POINTER(GLvoid)(table) ) -> None` glGetColorTableParameterfv(...) `glGetColorTableParameterfv( GLenum(target), GLenum(pname), arrays.GLfloatArray(params) ) -> None` glGetColorTableParameteriv(...) `glGetColorTableParameteriv( GLenum(target), GLenum(pname), arrays.GLintArray(params) ) -> None` glGetCompressedTexImage(...) `glGetCompressedTexImage( GLenum(target), GLint(lod), ctypes.POINTER(GLvoid)(img) ) -> None` glGetConvolutionFilter(...) `glGetConvolutionFilter( GLenum(target), GLenum(format), GLenum(type), ctypes.POINTER(GLvoid)(image) ) -> None` glGetConvolutionParameterfv(...) `glGetConvolutionParameterfv( GLenum(target), GLenum(pname), arrays.GLfloatArray(params) ) -> None` glGetConvolutionParameteriv(...) `glGetConvolutionParameteriv( GLenum(target), GLenum(pname), arrays.GLintArray(params) ) -> None` glGetDoublev(...) `glGetDoublev( GLenum(pname), arrays.GLdoubleArray(params) ) -> None` glGetError(...) `glGetError( ) -> GLenum` glGetFloatv(...) `glGetFloatv( GLenum(pname), arrays.GLfloatArray(params) ) -> None` glGetHistogram(...) `glGetHistogram( GLenum(target), GLboolean(reset), GLenum(format), GLenum(type), ctypes.POINTER(GLvoid)(values) ) -> None` glGetHistogramParameterfv(...) `glGetHistogramParameterfv( GLenum(target), GLenum(pname), arrays.GLfloatArray(params) ) -> None` glGetHistogramParameteriv(...) `glGetHistogramParameteriv( GLenum(target), GLenum(pname), arrays.GLintArray(params) ) -> None` glGetIntegerv(...) `glGetIntegerv( GLenum(pname), arrays.GLintArray(params) ) -> None` glGetLightfv(...) `glGetLightfv( GLenum(light), GLenum(pname), arrays.GLfloatArray(params) ) -> None` glGetLightiv(...) `glGetLightiv( GLenum(light), GLenum(pname), arrays.GLintArray(params) ) -> None` glGetMapdv(...) `glGetMapdv( GLenum(target), GLenum(query), arrays.GLdoubleArray(v) ) -> None` glGetMapfv(...) `glGetMapfv( GLenum(target), GLenum(query), arrays.GLfloatArray(v) ) -> None` glGetMapiv(...) `glGetMapiv( GLenum(target), GLenum(query), arrays.GLintArray(v) ) -> None` glGetMaterialfv(...) `glGetMaterialfv( GLenum(face), GLenum(pname), arrays.GLfloatArray(params) ) -> None` glGetMaterialiv(...) `glGetMaterialiv( GLenum(face), GLenum(pname), arrays.GLintArray(params) ) -> None` glGetMinmax(...) `glGetMinmax( GLenum(target), GLboolean(reset), GLenum(format), GLenum(types), ctypes.POINTER(GLvoid)(values) ) -> None` glGetMinmaxParameterfv(...) `glGetMinmaxParameterfv( GLenum(target), GLenum(pname), arrays.GLfloatArray(params) ) -> None` glGetMinmaxParameteriv(...) `glGetMinmaxParameteriv( GLenum(target), GLenum(pname), arrays.GLintArray(params) ) -> None` glGetPixelMapfv(...) `glGetPixelMapfv( GLenum(map), arrays.GLfloatArray(values) ) -> None` glGetPixelMapuiv(...) `glGetPixelMapuiv( GLenum(map), arrays.GLuintArray(values) ) -> None` glGetPixelMapusv(...) `glGetPixelMapusv( GLenum(map), arrays.GLushortArray(values) ) -> None` glGetPointerv(...) `glGetPointerv( GLenum(pname), ctypes.POINTER(ctypes.POINTER(GLvoid))(params) ) -> None` glGetPolygonStipple(...) `glGetPolygonStipple( arrays.GLubyteArray(mask) ) -> None` glGetSeparableFilter(...) `glGetSeparableFilter( GLenum(target), GLenum(format), GLenum(type), ctypes.POINTER(GLvoid)(row), ctypes.POINTER(GLvoid)(column), ctypes.POINTER(GLvoid)(span) ) -> None` glGetString(...) `glGetString( GLenum(name) ) -> ctypes.POINTER(GLubyte)` glGetTexEnvfv(...) `glGetTexEnvfv( GLenum(target), GLenum(pname), arrays.GLfloatArray(params) ) -> None` glGetTexEnviv(...) `glGetTexEnviv( GLenum(target), GLenum(pname), arrays.GLintArray(params) ) -> None` glGetTexGendv(...) `glGetTexGendv( GLenum(coord), GLenum(pname), arrays.GLdoubleArray(params) ) -> None` glGetTexGenfv(...) `glGetTexGenfv( GLenum(coord), GLenum(pname), arrays.GLfloatArray(params) ) -> None` glGetTexGeniv(...) `glGetTexGeniv( GLenum(coord), GLenum(pname), arrays.GLintArray(params) ) -> None` glGetTexImage(...) `glGetTexImage( GLenum(target), GLint(level), GLenum(format), GLenum(type), ctypes.POINTER(GLvoid)(pixels) ) -> None` glGetTexLevelParameterfv(...) `glGetTexLevelParameterfv( GLenum(target), GLint(level), GLenum(pname), arrays.GLfloatArray(params) ) -> None` glGetTexLevelParameteriv(...) `glGetTexLevelParameteriv( GLenum(target), GLint(level), GLenum(pname), arrays.GLintArray(params) ) -> None` glGetTexParameterfv(...) `glGetTexParameterfv( GLenum(target), GLenum(pname), arrays.GLfloatArray(params) ) -> None` glGetTexParameteriv(...) `glGetTexParameteriv( GLenum(target), GLenum(pname), arrays.GLintArray(params) ) -> None` glHint(...) `glHint( GLenum(target), GLenum(mode) ) -> None` glHistogram(...) `glHistogram( GLenum(target), GLsizei(width), GLenum(internalformat), GLboolean(sink) ) -> None` glIndexMask(...) `glIndexMask( GLuint(mask) ) -> None` glIndexPointer(...) `glIndexPointer( GLenum(type), GLsizei(stride), ctypes.POINTER(GLvoid)(ptr) ) -> None` glIndexd(...) `glIndexd( GLdouble(c) ) -> None` glIndexdv( c ) pyConverters: c= asArraySize(incoming, function, args) cConverters: c=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glIndexdv( arrays.GLdoubleArray(c) ) -> None
> glIndexf(...) `glIndexf( GLfloat(c) ) -> None` glIndexfv( c ) pyConverters: c= asArraySize(incoming, function, args) cConverters: c=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glIndexfv( arrays.GLfloatArray(c) ) -> None
> glIndexi(...) `glIndexi( GLint(c) ) -> None` glIndexiv( c ) pyConverters: c=<OpenGL.converters.CallFuncPyConverter object> cConverters: c=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glIndexiv( arrays.GLintArray(c) ) -> None
> glIndexs(...) `glIndexs( GLshort(c) ) -> None` glIndexsv( c ) pyConverters: c= asArraySize(incoming, function, args) cConverters: c=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glIndexsv( arrays.GLshortArray(c) ) -> None
> glIndexub(...) `glIndexub( GLubyte(c) ) -> None` glIndexubv( c ) pyConverters: c= asArraySize(incoming, function, args) cConverters: c=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glIndexubv( arrays.GLubyteArray(c) ) -> None
> glInitNames(...) `glInitNames( ) -> None` glInterleavedArrays(...) `glInterleavedArrays( GLenum(format), GLsizei(stride), ctypes.POINTER(GLvoid)(pointer) ) -> None` glIsEnabled(...) `glIsEnabled( GLenum(cap) ) -> GLboolean` glIsList(...) `glIsList( GLuint(list) ) -> GLboolean` glIsTexture(...) `glIsTexture( GLuint(texture) ) -> GLboolean` glLightModelf(...) `glLightModelf( GLenum(pname), GLfloat(param) ) -> None` glLightModelfv( pname,params ) pyConverters: pname=None, params=<OpenGL.converters.CallFuncPyConverter object> cConverters: pname=None, params=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glLightModelfv( GLenum(pname), arrays.GLfloatArray(params) ) -> None
> glLightModeli(...) `glLightModeli( GLenum(pname), GLint(param) ) -> None` glLightModeliv( pname,params ) pyConverters: pname=None, params=<OpenGL.converters.CallFuncPyConverter object> cConverters: pname=None, params=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glLightModeliv( GLenum(pname), arrays.GLintArray(params) ) -> None
> glLightf(...) `glLightf( GLenum(light), GLenum(pname), GLfloat(param) ) -> None` glLightfv( light,pname,params ) pyConverters: light=None, pname=None, params=<OpenGL.converters.CallFuncPyConverter object> cConverters: light=None, pname=None, params=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glLightfv( GLenum(light), GLenum(pname), arrays.GLfloatArray(params) ) -> None
> glLighti(...) `glLighti( GLenum(light), GLenum(pname), GLint(param) ) -> None` glLightiv( light,pname,params ) pyConverters: light=None, pname=None, params=<OpenGL.converters.CallFuncPyConverter object> cConverters: light=None, pname=None, params=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glLightiv( GLenum(light), GLenum(pname), arrays.GLintArray(params) ) -> None
> glLineStipple(...) `glLineStipple( GLint(factor), GLushort(pattern) ) -> None` glLineWidth(...) `glLineWidth( GLfloat(width) ) -> None` glListBase(...) `glListBase( GLuint(base) ) -> None` glLoadIdentity(...) `glLoadIdentity( ) -> None` glLoadMatrixd( m ) pyConverters: m= asArraySize(incoming, function, args) cConverters: m=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glLoadMatrixd( arrays.GLdoubleArray(m) ) -> None
> glLoadMatrixf( m ) pyConverters: m= asArraySize(incoming, function, args) cConverters: m=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glLoadMatrixf( arrays.GLfloatArray(m) ) -> None
> glLoadName(...) `glLoadName( GLuint(name) ) -> None` glLoadTransposeMatrixd( m ) pyConverters: m= asArraySize(incoming, function, args) cConverters: m=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glLoadTransposeMatrixd( arrays.GLdoubleArray(m) ) -> None
> glLoadTransposeMatrixf( m ) pyConverters: m= asArraySize(incoming, function, args) cConverters: m=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glLoadTransposeMatrixf( arrays.GLfloatArray(m) ) -> None
> glLogicOp(...) `glLogicOp( GLenum(opcode) ) -> None` glMap1d( target,u1,u2,stride,order,points ) pyConverters: target=None, u1=None, u2=None, stride=None, order=None, points=<OpenGL.converters.CallFuncPyConverter object> cConverters: target=None, u1=None, u2=None, stride=None, order=None, points=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: 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> cConverters: target=None, u1=None, u2=None, stride=None, order=None, points=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: 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> cConverters: target=None, u1=None, u2=None, ustride=None, uorder=None, v1=None, v2=None, vstride=None, vorder=None, points=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: 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> cConverters: target=None, u1=None, u2=None, ustride=None, uorder=None, v1=None, v2=None, vstride=None, vorder=None, points=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glMap2f( GLenum(target), GLfloat(u1), GLfloat(u2), GLint(ustride), GLint(uorder), GLfloat(v1), GLfloat(v2), GLint(vstride), GLint(vorder), arrays.GLfloatArray(points) ) -> None
> glMapGrid1d(...) `glMapGrid1d( GLint(un), GLdouble(u1), GLdouble(u2) ) -> None` glMapGrid1f(...) `glMapGrid1f( GLint(un), GLfloat(u1), GLfloat(u2) ) -> None` glMapGrid2d(...) `glMapGrid2d( GLint(un), GLdouble(u1), GLdouble(u2), GLint(vn), GLdouble(v1), GLdouble(v2) ) -> None` glMapGrid2f(...) `glMapGrid2f( GLint(un), GLfloat(u1), GLfloat(u2), GLint(vn), GLfloat(v1), GLfloat(v2) ) -> None` glMaterialf(...) `glMaterialf( GLenum(face), GLenum(pname), GLfloat(param) ) -> None` glMaterialfv( face,pname,params ) pyConverters: face=None, pname=None, params=<OpenGL.converters.CallFuncPyConverter object> cConverters: face=None, pname=None, params=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glMaterialfv( GLenum(face), GLenum(pname), arrays.GLfloatArray(params) ) -> None
> glMateriali(...) `glMateriali( GLenum(face), GLenum(pname), GLint(param) ) -> None` glMaterialiv( face,pname,params ) pyConverters: face=None, pname=None, params=<OpenGL.converters.CallFuncPyConverter object> cConverters: face=None, pname=None, params=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glMaterialiv( GLenum(face), GLenum(pname), arrays.GLintArray(params) ) -> None
> glMatrixMode(...) `glMatrixMode( GLenum(mode) ) -> None` glMinmax(...) `glMinmax( GLenum(target), GLenum(internalformat), GLboolean(sink) ) -> None` glMultMatrixd( m ) pyConverters: m= asArraySize(incoming, function, args) cConverters: m=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glMultMatrixd( arrays.GLdoubleArray(m) ) -> None
> glMultMatrixf( m ) pyConverters: m= asArraySize(incoming, function, args) cConverters: m=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glMultMatrixf( arrays.GLfloatArray(m) ) -> None
> glMultTransposeMatrixd( m ) pyConverters: m= asArraySize(incoming, function, args) cConverters: m=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glMultTransposeMatrixd( arrays.GLdoubleArray(m) ) -> None
> glMultTransposeMatrixf( m ) pyConverters: m= asArraySize(incoming, function, args) cConverters: m=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glMultTransposeMatrixf( arrays.GLfloatArray(m) ) -> None
> glMultiTexCoord1d(...) `glMultiTexCoord1d( GLenum(target), GLdouble(s) ) -> None` glMultiTexCoord1dARB(...) `glMultiTexCoord1dARB( GLenum(target), GLdouble(s) ) -> None` glMultiTexCoord1dv( target,v ) pyConverters: target=None, v= asArraySize(incoming, function, args) cConverters: target=None, v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glMultiTexCoord1dv( GLenum(target), arrays.GLdoubleArray(v) ) -> None
> glMultiTexCoord1dvARB( target,v ) pyConverters: target=None, v= asArraySize(incoming, function, args) cConverters: target=None, v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glMultiTexCoord1dvARB( GLenum(target), arrays.GLdoubleArray(v) ) -> None
> glMultiTexCoord1f(...) `glMultiTexCoord1f( GLenum(target), GLfloat(s) ) -> None` glMultiTexCoord1fARB(...) `glMultiTexCoord1fARB( GLenum(target), GLfloat(s) ) -> None` glMultiTexCoord1fv( target,v ) pyConverters: target=None, v= asArraySize(incoming, function, args) cConverters: target=None, v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glMultiTexCoord1fv( GLenum(target), arrays.GLfloatArray(v) ) -> None
> glMultiTexCoord1fvARB( target,v ) pyConverters: target=None, v= asArraySize(incoming, function, args) cConverters: target=None, v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glMultiTexCoord1fvARB( GLenum(target), arrays.GLfloatArray(v) ) -> None
> glMultiTexCoord1i(...) `glMultiTexCoord1i( GLenum(target), GLint(s) ) -> None` glMultiTexCoord1iARB(...) `glMultiTexCoord1iARB( GLenum(target), GLint(s) ) -> None` glMultiTexCoord1iv( target,v ) pyConverters: target=None, v= asArraySize(incoming, function, args) cConverters: target=None, v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glMultiTexCoord1iv( GLenum(target), arrays.GLintArray(v) ) -> None
> glMultiTexCoord1ivARB( target,v ) pyConverters: target=None, v= asArraySize(incoming, function, args) cConverters: target=None, v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glMultiTexCoord1ivARB( GLenum(target), arrays.GLintArray(v) ) -> None
> glMultiTexCoord1s(...) `glMultiTexCoord1s( GLenum(target), GLshort(s) ) -> None` glMultiTexCoord1sARB(...) `glMultiTexCoord1sARB( GLenum(target), GLshort(s) ) -> None` glMultiTexCoord1sv( target,v ) pyConverters: target=None, v= asArraySize(incoming, function, args) cConverters: target=None, v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glMultiTexCoord1sv( GLenum(target), arrays.GLshortArray(v) ) -> None
> glMultiTexCoord1svARB( target,v ) pyConverters: target=None, v= asArraySize(incoming, function, args) cConverters: target=None, v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glMultiTexCoord1svARB( GLenum(target), arrays.GLshortArray(v) ) -> None
> glMultiTexCoord2d(...) `glMultiTexCoord2d( GLenum(target), GLdouble(s), GLdouble(t) ) -> None` glMultiTexCoord2dARB(...) `glMultiTexCoord2dARB( GLenum(target), GLdouble(s), GLdouble(t) ) -> None` glMultiTexCoord2dv( target,v ) pyConverters: target=None, v= asArraySize(incoming, function, args) cConverters: target=None, v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glMultiTexCoord2dv( GLenum(target), arrays.GLdoubleArray(v) ) -> None
> glMultiTexCoord2dvARB( target,v ) pyConverters: target=None, v= asArraySize(incoming, function, args) cConverters: target=None, v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glMultiTexCoord2dvARB( GLenum(target), arrays.GLdoubleArray(v) ) -> None
> glMultiTexCoord2f(...) `glMultiTexCoord2f( GLenum(target), GLfloat(s), GLfloat(t) ) -> None` glMultiTexCoord2fARB(...) `glMultiTexCoord2fARB( GLenum(target), GLfloat(s), GLfloat(t) ) -> None` glMultiTexCoord2fv( target,v ) pyConverters: target=None, v= asArraySize(incoming, function, args) cConverters: target=None, v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glMultiTexCoord2fv( GLenum(target), arrays.GLfloatArray(v) ) -> None
> glMultiTexCoord2fvARB( target,v ) pyConverters: target=None, v= asArraySize(incoming, function, args) cConverters: target=None, v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glMultiTexCoord2fvARB( GLenum(target), arrays.GLfloatArray(v) ) -> None
> glMultiTexCoord2i(...) `glMultiTexCoord2i( GLenum(target), GLint(s), GLint(t) ) -> None` glMultiTexCoord2iARB(...) `glMultiTexCoord2iARB( GLenum(target), GLint(s), GLint(t) ) -> None` glMultiTexCoord2iv( target,v ) pyConverters: target=None, v= asArraySize(incoming, function, args) cConverters: target=None, v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glMultiTexCoord2iv( GLenum(target), arrays.GLintArray(v) ) -> None
> glMultiTexCoord2ivARB( target,v ) pyConverters: target=None, v= asArraySize(incoming, function, args) cConverters: target=None, v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glMultiTexCoord2ivARB( GLenum(target), arrays.GLintArray(v) ) -> None
> glMultiTexCoord2s(...) `glMultiTexCoord2s( GLenum(target), GLshort(s), GLshort(t) ) -> None` glMultiTexCoord2sARB(...) `glMultiTexCoord2sARB( GLenum(target), GLshort(s), GLshort(t) ) -> None` glMultiTexCoord2sv( target,v ) pyConverters: target=None, v= asArraySize(incoming, function, args) cConverters: target=None, v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glMultiTexCoord2sv( GLenum(target), arrays.GLshortArray(v) ) -> None
> glMultiTexCoord2svARB( target,v ) pyConverters: target=None, v= asArraySize(incoming, function, args) cConverters: target=None, v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glMultiTexCoord2svARB( GLenum(target), arrays.GLshortArray(v) ) -> None
> glMultiTexCoord3d(...) `glMultiTexCoord3d( GLenum(target), GLdouble(s), GLdouble(t), GLdouble(r) ) -> None` glMultiTexCoord3dARB(...) `glMultiTexCoord3dARB( GLenum(target), GLdouble(s), GLdouble(t), GLdouble(r) ) -> None` glMultiTexCoord3dv( target,v ) pyConverters: target=None, v= asArraySize(incoming, function, args) cConverters: target=None, v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glMultiTexCoord3dv( GLenum(target), arrays.GLdoubleArray(v) ) -> None
> glMultiTexCoord3dvARB( target,v ) pyConverters: target=None, v= asArraySize(incoming, function, args) cConverters: target=None, v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glMultiTexCoord3dvARB( GLenum(target), arrays.GLdoubleArray(v) ) -> None
> glMultiTexCoord3f(...) `glMultiTexCoord3f( GLenum(target), GLfloat(s), GLfloat(t), GLfloat(r) ) -> None` glMultiTexCoord3fARB(...) `glMultiTexCoord3fARB( GLenum(target), GLfloat(s), GLfloat(t), GLfloat(r) ) -> None` glMultiTexCoord3fv( target,v ) pyConverters: target=None, v= asArraySize(incoming, function, args) cConverters: target=None, v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glMultiTexCoord3fv( GLenum(target), arrays.GLfloatArray(v) ) -> None
> glMultiTexCoord3fvARB( target,v ) pyConverters: target=None, v= asArraySize(incoming, function, args) cConverters: target=None, v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glMultiTexCoord3fvARB( GLenum(target), arrays.GLfloatArray(v) ) -> None
> glMultiTexCoord3i(...) `glMultiTexCoord3i( GLenum(target), GLint(s), GLint(t), GLint(r) ) -> None` glMultiTexCoord3iARB(...) `glMultiTexCoord3iARB( GLenum(target), GLint(s), GLint(t), GLint(r) ) -> None` glMultiTexCoord3iv( target,v ) pyConverters: target=None, v= asArraySize(incoming, function, args) cConverters: target=None, v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glMultiTexCoord3iv( GLenum(target), arrays.GLintArray(v) ) -> None
> glMultiTexCoord3ivARB( target,v ) pyConverters: target=None, v= asArraySize(incoming, function, args) cConverters: target=None, v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glMultiTexCoord3ivARB( GLenum(target), arrays.GLintArray(v) ) -> None
> glMultiTexCoord3s(...) `glMultiTexCoord3s( GLenum(target), GLshort(s), GLshort(t), GLshort(r) ) -> None` glMultiTexCoord3sARB(...) `glMultiTexCoord3sARB( GLenum(target), GLshort(s), GLshort(t), GLshort(r) ) -> None` glMultiTexCoord3sv( target,v ) pyConverters: target=None, v= asArraySize(incoming, function, args) cConverters: target=None, v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glMultiTexCoord3sv( GLenum(target), arrays.GLshortArray(v) ) -> None
> glMultiTexCoord3svARB( target,v ) pyConverters: target=None, v= asArraySize(incoming, function, args) cConverters: target=None, v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glMultiTexCoord3svARB( GLenum(target), arrays.GLshortArray(v) ) -> None
> glMultiTexCoord4d(...) `glMultiTexCoord4d( GLenum(target), GLdouble(s), GLdouble(t), GLdouble(r), GLdouble(q) ) -> None` glMultiTexCoord4dARB(...) `glMultiTexCoord4dARB( GLenum(target), GLdouble(s), GLdouble(t), GLdouble(r), GLdouble(q) ) -> None` glMultiTexCoord4dv( target,v ) pyConverters: target=None, v= asArraySize(incoming, function, args) cConverters: target=None, v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glMultiTexCoord4dv( GLenum(target), arrays.GLdoubleArray(v) ) -> None
> glMultiTexCoord4dvARB( target,v ) pyConverters: target=None, v= asArraySize(incoming, function, args) cConverters: target=None, v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glMultiTexCoord4dvARB( GLenum(target), arrays.GLdoubleArray(v) ) -> None
> glMultiTexCoord4f(...) `glMultiTexCoord4f( GLenum(target), GLfloat(s), GLfloat(t), GLfloat(r), GLfloat(q) ) -> None` glMultiTexCoord4fARB(...) `glMultiTexCoord4fARB( GLenum(target), GLfloat(s), GLfloat(t), GLfloat(r), GLfloat(q) ) -> None` glMultiTexCoord4fv( target,v ) pyConverters: target=None, v= asArraySize(incoming, function, args) cConverters: target=None, v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glMultiTexCoord4fv( GLenum(target), arrays.GLfloatArray(v) ) -> None
> glMultiTexCoord4fvARB( target,v ) pyConverters: target=None, v= asArraySize(incoming, function, args) cConverters: target=None, v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glMultiTexCoord4fvARB( GLenum(target), arrays.GLfloatArray(v) ) -> None
> glMultiTexCoord4i(...) `glMultiTexCoord4i( GLenum(target), GLint(s), GLint(t), GLint(r), GLint(q) ) -> None` glMultiTexCoord4iARB(...) `glMultiTexCoord4iARB( GLenum(target), GLint(s), GLint(t), GLint(r), GLint(q) ) -> None` glMultiTexCoord4iv( target,v ) pyConverters: target=None, v= asArraySize(incoming, function, args) cConverters: target=None, v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glMultiTexCoord4iv( GLenum(target), arrays.GLintArray(v) ) -> None
> glMultiTexCoord4ivARB( target,v ) pyConverters: target=None, v= asArraySize(incoming, function, args) cConverters: target=None, v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glMultiTexCoord4ivARB( GLenum(target), arrays.GLintArray(v) ) -> None
> glMultiTexCoord4s(...) `glMultiTexCoord4s( GLenum(target), GLshort(s), GLshort(t), GLshort(r), GLshort(q) ) -> None` glMultiTexCoord4sARB(...) `glMultiTexCoord4sARB( GLenum(target), GLshort(s), GLshort(t), GLshort(r), GLshort(q) ) -> None` glMultiTexCoord4sv( target,v ) pyConverters: target=None, v= asArraySize(incoming, function, args) cConverters: target=None, v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glMultiTexCoord4sv( GLenum(target), arrays.GLshortArray(v) ) -> None
> glMultiTexCoord4svARB( target,v ) pyConverters: target=None, v= asArraySize(incoming, function, args) cConverters: target=None, v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glMultiTexCoord4svARB( GLenum(target), arrays.GLshortArray(v) ) -> None
> glNewList(...) `glNewList( GLuint(list), GLenum(mode) ) -> None` glNormal3b(...) `glNormal3b( GLbyte(nx), GLbyte(ny), GLbyte(nz) ) -> None` glNormal3bv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glNormal3bv( arrays.GLbyteArray(v) ) -> None
> glNormal3d(...) `glNormal3d( GLdouble(nx), GLdouble(ny), GLdouble(nz) ) -> None` glNormal3dv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glNormal3dv( arrays.GLdoubleArray(v) ) -> None
> glNormal3f(...) `glNormal3f( GLfloat(nx), GLfloat(ny), GLfloat(nz) ) -> None` glNormal3fv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glNormal3fv( arrays.GLfloatArray(v) ) -> None
> glNormal3i(...) `glNormal3i( GLint(nx), GLint(ny), GLint(nz) ) -> None` glNormal3iv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glNormal3iv( arrays.GLintArray(v) ) -> None
> glNormal3s(...) `glNormal3s( GLshort(nx), GLshort(ny), GLshort(nz) ) -> None` glNormal3sv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glNormal3sv( arrays.GLshortArray(v) ) -> None
> glNormalPointer(...) `glNormalPointer( GLenum(type), GLsizei(stride), ctypes.POINTER(GLvoid)(ptr) ) -> None` glOrtho(...) `glOrtho( GLdouble(left), GLdouble(right), GLdouble(bottom), GLdouble(top), GLdouble(near_val), GLdouble(far_val) ) -> None` glPassThrough(...) `glPassThrough( GLfloat(token) ) -> None` glPixelMapfv( map,mapsize,values ) pyConverters: map=None, mapsize=None, values=<OpenGL.converters.CallFuncPyConverter object> cConverters: map=None, mapsize=None, values=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glPixelMapfv( GLenum(map), GLsizei(mapsize), arrays.GLfloatArray(values) ) -> None
> glPixelMapuiv( map,mapsize,values ) pyConverters: map=None, mapsize=None, values=<OpenGL.converters.CallFuncPyConverter object> cConverters: map=None, mapsize=None, values=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glPixelMapuiv( GLenum(map), GLsizei(mapsize), arrays.GLuintArray(values) ) -> None
> glPixelMapusv( map,mapsize,values ) pyConverters: map=None, mapsize=None, values=<OpenGL.converters.CallFuncPyConverter object> cConverters: map=None, mapsize=None, values=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glPixelMapusv( GLenum(map), GLsizei(mapsize), arrays.GLushortArray(values) ) -> None
> glPixelStoref(...) `glPixelStoref( GLenum(pname), GLfloat(param) ) -> None` glPixelStorei(...) `glPixelStorei( GLenum(pname), GLint(param) ) -> None` glPixelTransferf(...) `glPixelTransferf( GLenum(pname), GLfloat(param) ) -> None` glPixelTransferi(...) `glPixelTransferi( GLenum(pname), GLint(param) ) -> None` glPixelZoom(...) `glPixelZoom( GLfloat(xfactor), GLfloat(yfactor) ) -> None` glPointSize(...) `glPointSize( GLfloat(size) ) -> None` glPolygonMode(...) `glPolygonMode( GLenum(face), GLenum(mode) ) -> None` glPolygonOffset(...) `glPolygonOffset( GLfloat(factor), GLfloat(units) ) -> None` glPolygonStipple( mask ) pyConverters: mask=<OpenGL.converters.CallFuncPyConverter object> cConverters: mask=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glPolygonStipple( arrays.GLubyteArray(mask) ) -> None
> glPopAttrib(...) `glPopAttrib( ) -> None` glPopClientAttrib(...) `glPopClientAttrib( ) -> None` glPopMatrix(...) `glPopMatrix( ) -> None` glPopName(...) `glPopName( ) -> None` glPrioritizeTextures( n,textures,priorities ) pyConverters: n=None, textures=<OpenGL.converters.CallFuncPyConverter object>, priorities=<OpenGL.converters.CallFuncPyConverter object> cConverters: n=None, textures=<OpenGL.converters.getPyArgsName object>, priorities=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glPrioritizeTextures( GLsizei(n), arrays.GLuintArray(textures), arrays.GLclampfArray(priorities) ) -> None
> glPushAttrib(...) `glPushAttrib( GLbitfield(mask) ) -> None` glPushClientAttrib(...) `glPushClientAttrib( GLbitfield(mask) ) -> None` glPushMatrix(...) `glPushMatrix( ) -> None` glPushName(...) `glPushName( GLuint(name) ) -> None` glRasterPos2d(...) `glRasterPos2d( GLdouble(x), GLdouble(y) ) -> None` glRasterPos2dv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glRasterPos2dv( arrays.GLdoubleArray(v) ) -> None
> glRasterPos2f(...) `glRasterPos2f( GLfloat(x), GLfloat(y) ) -> None` glRasterPos2fv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glRasterPos2fv( arrays.GLfloatArray(v) ) -> None
> glRasterPos2i(...) `glRasterPos2i( GLint(x), GLint(y) ) -> None` glRasterPos2iv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glRasterPos2iv( arrays.GLintArray(v) ) -> None
> glRasterPos2s(...) `glRasterPos2s( GLshort(x), GLshort(y) ) -> None` glRasterPos2sv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glRasterPos2sv( arrays.GLshortArray(v) ) -> None
> glRasterPos3d(...) `glRasterPos3d( GLdouble(x), GLdouble(y), GLdouble(z) ) -> None` glRasterPos3dv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glRasterPos3dv( arrays.GLdoubleArray(v) ) -> None
> glRasterPos3f(...) `glRasterPos3f( GLfloat(x), GLfloat(y), GLfloat(z) ) -> None` glRasterPos3fv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glRasterPos3fv( arrays.GLfloatArray(v) ) -> None
> glRasterPos3i(...) `glRasterPos3i( GLint(x), GLint(y), GLint(z) ) -> None` glRasterPos3iv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glRasterPos3iv( arrays.GLintArray(v) ) -> None
> glRasterPos3s(...) `glRasterPos3s( GLshort(x), GLshort(y), GLshort(z) ) -> None` glRasterPos3sv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glRasterPos3sv( arrays.GLshortArray(v) ) -> None
> glRasterPos4d(...) `glRasterPos4d( GLdouble(x), GLdouble(y), GLdouble(z), GLdouble(w) ) -> None` glRasterPos4dv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glRasterPos4dv( arrays.GLdoubleArray(v) ) -> None
> glRasterPos4f(...) `glRasterPos4f( GLfloat(x), GLfloat(y), GLfloat(z), GLfloat(w) ) -> None` glRasterPos4fv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glRasterPos4fv( arrays.GLfloatArray(v) ) -> None
> glRasterPos4i(...) `glRasterPos4i( GLint(x), GLint(y), GLint(z), GLint(w) ) -> None` glRasterPos4iv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glRasterPos4iv( arrays.GLintArray(v) ) -> None
> glRasterPos4s(...) `glRasterPos4s( GLshort(x), GLshort(y), GLshort(z), GLshort(w) ) -> None` glRasterPos4sv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glRasterPos4sv( arrays.GLshortArray(v) ) -> None
> glReadBuffer(...) `glReadBuffer( GLenum(mode) ) -> None` glReadPixels(...) `glReadPixels( GLint(x), GLint(y), GLsizei(width), GLsizei(height), GLenum(format), GLenum(type), ctypes.POINTER(GLvoid)(pixels) ) -> None` glRectd(...) `glRectd( GLdouble(x1), GLdouble(y1), GLdouble(x2), GLdouble(y2) ) -> None` glRectdv( v1,v2 ) pyConverters: v1=<OpenGL.converters.CallFuncPyConverter object>, v2=<OpenGL.converters.CallFuncPyConverter object> cConverters: v1=<OpenGL.converters.getPyArgsName object>, v2=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glRectdv( arrays.GLdoubleArray(v1), arrays.GLdoubleArray(v2) ) -> None
> glRectf(...) `glRectf( GLfloat(x1), GLfloat(y1), GLfloat(x2), GLfloat(y2) ) -> None` glRectfv( v1,v2 ) pyConverters: v1= asArraySize(incoming, function, args) , v2= asArraySize(incoming, function, args) cConverters: v1=<OpenGL.converters.getPyArgsName object>, v2=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glRectfv( arrays.GLfloatArray(v1), arrays.GLfloatArray(v2) ) -> None
> glRecti(...) `glRecti( GLint(x1), GLint(y1), GLint(x2), GLint(y2) ) -> None` glRectiv( v1,v2 ) pyConverters: v1= asArraySize(incoming, function, args) , v2= asArraySize(incoming, function, args) cConverters: v1=<OpenGL.converters.getPyArgsName object>, v2=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glRectiv( arrays.GLintArray(v1), arrays.GLintArray(v2) ) -> None
> glRects(...) `glRects( GLshort(x1), GLshort(y1), GLshort(x2), GLshort(y2) ) -> None` glRectsv( v1,v2 ) pyConverters: v1= asArraySize(incoming, function, args) , v2= asArraySize(incoming, function, args) cConverters: v1=<OpenGL.converters.getPyArgsName object>, v2=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glRectsv( arrays.GLshortArray(v1), arrays.GLshortArray(v2) ) -> None
> glRenderMode(...) `glRenderMode( GLenum(mode) ) -> GLint` glResetHistogram(...) `glResetHistogram( GLenum(target) ) -> None` glResetMinmax(...) `glResetMinmax( GLenum(target) ) -> None` glRotated(...) `glRotated( GLdouble(angle), GLdouble(x), GLdouble(y), GLdouble(z) ) -> None` glRotatef(...) `glRotatef( GLfloat(angle), GLfloat(x), GLfloat(y), GLfloat(z) ) -> None` glSampleCoverage(...) `glSampleCoverage( GLclampf(value), GLboolean(invert) ) -> None` glScaled(...) `glScaled( GLdouble(x), GLdouble(y), GLdouble(z) ) -> None` glScalef(...) `glScalef( GLfloat(x), GLfloat(y), GLfloat(z) ) -> None` glScissor(...) `glScissor( GLint(x), GLint(y), GLsizei(width), GLsizei(height) ) -> None` glSelectBuffer( size,buffer ) pyConverters: size=None, buffer=<OpenGL.converters.CallFuncPyConverter object> cConverters: size=None, buffer=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glSelectBuffer( GLsizei(size), arrays.GLuintArray(buffer) ) -> None
> glSeparableFilter2D(...) `glSeparableFilter2D( GLenum(target), GLenum(internalformat), GLsizei(width), GLsizei(height), GLenum(format), GLenum(type), ctypes.POINTER(GLvoid)(row), ctypes.POINTER(GLvoid)(column) ) -> None` glShadeModel(...) `glShadeModel( GLenum(mode) ) -> None` glStencilFunc(...) `glStencilFunc( GLenum(func), GLint(ref), GLuint(mask) ) -> None` glStencilMask(...) `glStencilMask( GLuint(mask) ) -> None` glStencilOp(...) `glStencilOp( GLenum(fail), GLenum(zfail), GLenum(zpass) ) -> None` glTexCoord1d(...) `glTexCoord1d( GLdouble(s) ) -> None` glTexCoord1dv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glTexCoord1dv( arrays.GLdoubleArray(v) ) -> None
> glTexCoord1f(...) `glTexCoord1f( GLfloat(s) ) -> None` glTexCoord1fv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glTexCoord1fv( arrays.GLfloatArray(v) ) -> None
> glTexCoord1i(...) `glTexCoord1i( GLint(s) ) -> None` glTexCoord1iv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glTexCoord1iv( arrays.GLintArray(v) ) -> None
> glTexCoord1s(...) `glTexCoord1s( GLshort(s) ) -> None` glTexCoord1sv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glTexCoord1sv( arrays.GLshortArray(v) ) -> None
> glTexCoord2d(...) `glTexCoord2d( GLdouble(s), GLdouble(t) ) -> None` glTexCoord2dv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glTexCoord2dv( arrays.GLdoubleArray(v) ) -> None
> glTexCoord2f(...) `glTexCoord2f( GLfloat(s), GLfloat(t) ) -> None` glTexCoord2fv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glTexCoord2fv( arrays.GLfloatArray(v) ) -> None
> glTexCoord2i(...) `glTexCoord2i( GLint(s), GLint(t) ) -> None` glTexCoord2iv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glTexCoord2iv( arrays.GLintArray(v) ) -> None
> glTexCoord2s(...) `glTexCoord2s( GLshort(s), GLshort(t) ) -> None` glTexCoord2sv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glTexCoord2sv( arrays.GLshortArray(v) ) -> None
> glTexCoord3d(...) `glTexCoord3d( GLdouble(s), GLdouble(t), GLdouble(r) ) -> None` glTexCoord3dv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glTexCoord3dv( arrays.GLdoubleArray(v) ) -> None
> glTexCoord3f(...) `glTexCoord3f( GLfloat(s), GLfloat(t), GLfloat(r) ) -> None` glTexCoord3fv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glTexCoord3fv( arrays.GLfloatArray(v) ) -> None
> glTexCoord3i(...) `glTexCoord3i( GLint(s), GLint(t), GLint(r) ) -> None` glTexCoord3iv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glTexCoord3iv( arrays.GLintArray(v) ) -> None
> glTexCoord3s(...) `glTexCoord3s( GLshort(s), GLshort(t), GLshort(r) ) -> None` glTexCoord3sv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glTexCoord3sv( arrays.GLshortArray(v) ) -> None
> glTexCoord4d(...) `glTexCoord4d( GLdouble(s), GLdouble(t), GLdouble(r), GLdouble(q) ) -> None` glTexCoord4dv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glTexCoord4dv( arrays.GLdoubleArray(v) ) -> None
> glTexCoord4f(...) `glTexCoord4f( GLfloat(s), GLfloat(t), GLfloat(r), GLfloat(q) ) -> None` glTexCoord4fv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glTexCoord4fv( arrays.GLfloatArray(v) ) -> None
> glTexCoord4i(...) `glTexCoord4i( GLint(s), GLint(t), GLint(r), GLint(q) ) -> None` glTexCoord4iv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glTexCoord4iv( arrays.GLintArray(v) ) -> None
> glTexCoord4s(...) `glTexCoord4s( GLshort(s), GLshort(t), GLshort(r), GLshort(q) ) -> None` glTexCoord4sv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glTexCoord4sv( arrays.GLshortArray(v) ) -> None
> glTexCoordPointer(...) `glTexCoordPointer( GLint(size), GLenum(type), GLsizei(stride), ctypes.POINTER(GLvoid)(ptr) ) -> None` glTexEnvf(...) `glTexEnvf( GLenum(target), GLenum(pname), GLfloat(param) ) -> None` glTexEnvfv( target,pname,params ) pyConverters: target=None, pname=None, params=<OpenGL.converters.CallFuncPyConverter object> cConverters: target=None, pname=None, params=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glTexEnvfv( GLenum(target), GLenum(pname), arrays.GLfloatArray(params) ) -> None
> glTexEnvi(...) `glTexEnvi( GLenum(target), GLenum(pname), GLint(param) ) -> None` glTexEnviv( target,pname,params ) pyConverters: target=None, pname=None, params=<OpenGL.converters.CallFuncPyConverter object> cConverters: target=None, pname=None, params=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glTexEnviv( GLenum(target), GLenum(pname), arrays.GLintArray(params) ) -> None
> glTexGend(...) `glTexGend( GLenum(coord), GLenum(pname), GLdouble(param) ) -> None` glTexGendv( coord,pname,params ) pyConverters: coord=None, pname=None, params=<OpenGL.converters.CallFuncPyConverter object> cConverters: coord=None, pname=None, params=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glTexGendv( GLenum(coord), GLenum(pname), arrays.GLdoubleArray(params) ) -> None
> glTexGenf(...) `glTexGenf( GLenum(coord), GLenum(pname), GLfloat(param) ) -> None` glTexGenfv( coord,pname,params ) pyConverters: coord=None, pname=None, params=<OpenGL.converters.CallFuncPyConverter object> cConverters: coord=None, pname=None, params=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glTexGenfv( GLenum(coord), GLenum(pname), arrays.GLfloatArray(params) ) -> None
> glTexGeni(...) `glTexGeni( GLenum(coord), GLenum(pname), GLint(param) ) -> None` glTexGeniv( coord,pname,params ) pyConverters: coord=None, pname=None, params=<OpenGL.converters.CallFuncPyConverter object> cConverters: coord=None, pname=None, params=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glTexGeniv( GLenum(coord), GLenum(pname), arrays.GLintArray(params) ) -> None
> glTexImage1D(...) `glTexImage1D( GLenum(target), GLint(level), GLint(internalFormat), GLsizei(width), GLint(border), GLenum(format), GLenum(type), ctypes.POINTER(GLvoid)(pixels) ) -> None` glTexImage2D(...) `glTexImage2D( GLenum(target), GLint(level), GLint(internalFormat), GLsizei(width), GLsizei(height), GLint(border), GLenum(format), GLenum(type), ctypes.POINTER(GLvoid)(pixels) ) -> None` glTexImage3D(...) `glTexImage3D( GLenum(target), GLint(level), GLint(internalFormat), GLsizei(width), GLsizei(height), GLsizei(depth), GLint(border), GLenum(format), GLenum(type), ctypes.POINTER(GLvoid)(pixels) ) -> None` glTexParameterf(...) `glTexParameterf( GLenum(target), GLenum(pname), GLfloat(param) ) -> None` glTexParameterfv( target,pname,params ) pyConverters: target=None, pname=None, params=<OpenGL.converters.CallFuncPyConverter object> cConverters: target=None, pname=None, params=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glTexParameterfv( GLenum(target), GLenum(pname), arrays.GLfloatArray(params) ) -> None
> glTexParameteri(...) `glTexParameteri( GLenum(target), GLenum(pname), GLint(param) ) -> None` glTexParameteriv( target,pname,params ) pyConverters: target=None, pname=None, params=<OpenGL.converters.CallFuncPyConverter object> cConverters: target=None, pname=None, params=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glTexParameteriv( GLenum(target), GLenum(pname), arrays.GLintArray(params) ) -> None
> glTexSubImage1D(...) `glTexSubImage1D( GLenum(target), GLint(level), GLint(xoffset), GLsizei(width), GLenum(format), GLenum(type), ctypes.POINTER(GLvoid)(pixels) ) -> None` glTexSubImage2D(...) `glTexSubImage2D( GLenum(target), GLint(level), GLint(xoffset), GLint(yoffset), GLsizei(width), GLsizei(height), GLenum(format), GLenum(type), ctypes.POINTER(GLvoid)(pixels) ) -> None` glTexSubImage3D(...) `glTexSubImage3D( GLenum(target), GLint(level), GLint(xoffset), GLint(yoffset), GLint(zoffset), GLsizei(width), GLsizei(height), GLsizei(depth), GLenum(format), GLenum(type), ctypes.POINTER(GLvoid)(pixels) ) -> None` glTranslated(...) `glTranslated( GLdouble(x), GLdouble(y), GLdouble(z) ) -> None` glTranslatef(...) `glTranslatef( GLfloat(x), GLfloat(y), GLfloat(z) ) -> None` glVertex2d(...) `glVertex2d( GLdouble(x), GLdouble(y) ) -> None` glVertex2dv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glVertex2dv( arrays.GLdoubleArray(v) ) -> None
> glVertex2f(...) `glVertex2f( GLfloat(x), GLfloat(y) ) -> None` glVertex2fv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glVertex2fv( arrays.GLfloatArray(v) ) -> None
> glVertex2i(...) `glVertex2i( GLint(x), GLint(y) ) -> None` glVertex2iv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glVertex2iv( arrays.GLintArray(v) ) -> None
> glVertex2s(...) `glVertex2s( GLshort(x), GLshort(y) ) -> None` glVertex2sv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glVertex2sv( arrays.GLshortArray(v) ) -> None
> glVertex3d(...) `glVertex3d( GLdouble(x), GLdouble(y), GLdouble(z) ) -> None` glVertex3dv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glVertex3dv( arrays.GLdoubleArray(v) ) -> None
> glVertex3f(...) `glVertex3f( GLfloat(x), GLfloat(y), GLfloat(z) ) -> None` glVertex3fv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glVertex3fv( arrays.GLfloatArray(v) ) -> None
> glVertex3i(...) `glVertex3i( GLint(x), GLint(y), GLint(z) ) -> None` glVertex3iv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glVertex3iv( arrays.GLintArray(v) ) -> None
> glVertex3s(...) `glVertex3s( GLshort(x), GLshort(y), GLshort(z) ) -> None` glVertex3sv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glVertex3sv( arrays.GLshortArray(v) ) -> None
> glVertex4d(...) `glVertex4d( GLdouble(x), GLdouble(y), GLdouble(z), GLdouble(w) ) -> None` glVertex4dv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glVertex4dv( arrays.GLdoubleArray(v) ) -> None
> glVertex4f(...) `glVertex4f( GLfloat(x), GLfloat(y), GLfloat(z), GLfloat(w) ) -> None` glVertex4fv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glVertex4fv( arrays.GLfloatArray(v) ) -> None
> glVertex4i(...) `glVertex4i( GLint(x), GLint(y), GLint(z), GLint(w) ) -> None` glVertex4iv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glVertex4iv( arrays.GLintArray(v) ) -> None
> glVertex4s(...) `glVertex4s( GLshort(x), GLshort(y), GLshort(z), GLshort(w) ) -> None` glVertex4sv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glVertex4sv( arrays.GLshortArray(v) ) -> None
glVertexPointer(...) `glVertexPointer( GLint(size), GLenum(type), GLsizei(stride), ctypes.POINTER(GLvoid)(ptr) ) -> None` glViewport(...) `glViewport( GLint(x), GLint(y), GLsizei(width), GLsizei(height) ) -> None`

Data
`` |  | GLvoid = None glBlendEquationSeparateATI = <OpenGL.platform.glBlendEquationSeparateATI object>