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