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>