OpenGL.raw.GLU.annotations
index
/build/buildd/pyopengl-3.0.0~b3/OpenGL/raw/GLU/annotations.py

Array-size annotations for OpenGL.raw.GLU
 
Automatically generated by the generateraw script, do not edit!

 
Modules
       
OpenGL.constants
OpenGL.arrays
OpenGL.platform
OpenGL.raw.GLU
ctypes.util

 
Functions
       
addressof(...)
addressof(C instance) -> integer
Return the address of the C instance internal buffer
alignment(...)
alignment(C type) -> integer
alignment(C instance) -> integer
Return the alignment requirements of a C instance
byref(...)
byref(C instance) -> byref-object
Return a pointer lookalike to a C instance, only usable
as function argument
gluCheckExtension( extName,extString )
pyConverters: extName=<OpenGL.converters.CallFuncPyConverter object at 0x87c3e6c>, extString=<OpenGL.converters.CallFuncPyConverter object at 0x87c3e2c>
cConverters: extName=<OpenGL.converters.getPyArgsName object at 0x87b4644>, extString=<OpenGL.converters.getPyArgsName object at 0x87b4694>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: gluCheckExtension( arrays.GLubyteArray(extName), arrays.GLubyteArray(extString) ) -> GLboolean
gluGetNurbsProperty( nurb,property,data )
pyConverters: nurb=None, property=None, data=<OpenGL.converters.CallFuncPyConverter object at 0x82877ec>
cConverters: nurb=None, property=None, data=<OpenGL.converters.getPyArgsName object at 0x87b470c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: gluGetNurbsProperty( POINTER(GLUnurbs)(nurb), GLenum(property), arrays.GLfloatArray(data) ) -> None
gluGetTessProperty( tess,which,data )
pyConverters: tess=None, which=None, data=<OpenGL.converters.CallFuncPyConverter object at 0x8287bec>
cConverters: tess=None, which=None, data=<OpenGL.converters.getPyArgsName object at 0x87b4784>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: gluGetTessProperty( POINTER(GLUtesselator)(tess), GLenum(which), arrays.GLdoubleArray(data) ) -> None
gluLoadSamplingMatrices( nurb,model,perspective,view )
pyConverters: nurb=None, model=<OpenGL.converters.CallFuncPyConverter object at 0x8b652cc>, perspective=<OpenGL.converters.CallFuncPyConverter object at 0x8b65acc>, view=<OpenGL.converters.CallFuncPyConverter object at 0x8b6514c>
cConverters: nurb=None, model=<OpenGL.converters.getPyArgsName object at 0x87b47fc>, perspective=<OpenGL.converters.getPyArgsName object at 0x87b484c>, view=<OpenGL.converters.getPyArgsName object at 0x87b489c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: gluLoadSamplingMatrices( POINTER(GLUnurbs)(nurb), arrays.GLfloatArray(model), arrays.GLfloatArray(perspective), arrays.GLintArray(view) ) -> None
gluNurbsCurve( nurb,knotCount,knots,stride,control,order,type )
pyConverters: nurb=None, knotCount=None, knots=<OpenGL.converters.CallFuncPyConverter object at 0x8b656cc>, stride=None, control=<OpenGL.converters.CallFuncPyConverter object at 0x8b653ec>, order=None, type=None
cConverters: nurb=None, knotCount=None, knots=<OpenGL.converters.getPyArgsName object at 0x87b4914>, stride=None, control=<OpenGL.converters.getPyArgsName object at 0x87b4964>, order=None, type=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: gluNurbsCurve( POINTER(GLUnurbs)(nurb), GLint(knotCount), arrays.GLfloatArray(knots), GLint(stride), arrays.GLfloatArray(control), GLint(order), GLenum(type) ) -> None
gluNurbsSurface( nurb,sKnotCount,sKnots,tKnotCount,tKnots,sStride,tStride,control,sOrder,tOrder,type )
pyConverters: nurb=None, sKnotCount=None, sKnots=<OpenGL.converters.CallFuncPyConverter object at 0x8b655ac>, tKnotCount=None, tKnots=<OpenGL.converters.CallFuncPyConverter object at 0x8b658ac>, sStride=None, tStride=None, control=<OpenGL.converters.CallFuncPyConverter object at 0x8b650ec>, sOrder=None, tOrder=None, type=None
cConverters: nurb=None, sKnotCount=None, sKnots=<OpenGL.converters.getPyArgsName object at 0x87b49dc>, tKnotCount=None, tKnots=<OpenGL.converters.getPyArgsName object at 0x87b4a2c>, sStride=None, tStride=None, control=<OpenGL.converters.getPyArgsName object at 0x87b4a7c>, sOrder=None, tOrder=None, type=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: gluNurbsSurface( POINTER(GLUnurbs)(nurb), GLint(sKnotCount), arrays.GLfloatArray(sKnots), GLint(tKnotCount), arrays.GLfloatArray(tKnots), GLint(sStride), GLint(tStride), arrays.GLfloatArray(control), GLint(sOrder), GLint(tOrder), GLenum(type) ) -> None
gluPickMatrix( x,y,delX,delY,viewport )
pyConverters: x=None, y=None, delX=None, delY=None, viewport=<OpenGL.converters.CallFuncPyConverter object at 0x8b6554c>
cConverters: x=None, y=None, delX=None, delY=None, viewport=<OpenGL.converters.getPyArgsName object at 0x87b4af4>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: gluPickMatrix( GLdouble(x), GLdouble(y), GLdouble(delX), GLdouble(delY), arrays.GLintArray(viewport) ) -> None
gluProject( objX,objY,objZ,model,proj,view,winX,winY,winZ )
pyConverters: objX=None, objY=None, objZ=None, model=<OpenGL.converters.CallFuncPyConverter object at 0x8b6574c>, proj=<OpenGL.converters.CallFuncPyConverter object at 0x8b651ec>, view=<OpenGL.converters.CallFuncPyConverter object at 0x8b6530c>, winX=<OpenGL.converters.CallFuncPyConverter object at 0x8b65c0c>, winY=<OpenGL.converters.CallFuncPyConverter object at 0x8b658ec>, winZ=<OpenGL.converters.CallFuncPyConverter object at 0x8b65bec>
cConverters: objX=None, objY=None, objZ=None, model=<OpenGL.converters.getPyArgsName object at 0x87b4b6c>, proj=<OpenGL.converters.getPyArgsName object at 0x87b4bbc>, view=<OpenGL.converters.getPyArgsName object at 0x87b4c0c>, winX=<OpenGL.converters.getPyArgsName object at 0x87b4c5c>, winY=<OpenGL.converters.getPyArgsName object at 0x87b4cac>, winZ=<OpenGL.converters.getPyArgsName object at 0x87b4cfc>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: gluProject( GLdouble(objX), GLdouble(objY), GLdouble(objZ), arrays.GLdoubleArray(model), arrays.GLdoubleArray(proj), arrays.GLintArray(view), arrays.GLdoubleArray(winX), arrays.GLdoubleArray(winY), arrays.GLdoubleArray(winZ) ) -> GLint
gluPwlCurve( nurb,count,data,stride,type )
pyConverters: nurb=None, count=None, data=<OpenGL.converters.CallFuncPyConverter object at 0x8b6576c>, stride=None, type=None
cConverters: nurb=None, count=None, data=<OpenGL.converters.getPyArgsName object at 0x87b4d74>, stride=None, type=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: gluPwlCurve( POINTER(GLUnurbs)(nurb), GLint(count), arrays.GLfloatArray(data), GLint(stride), GLenum(type) ) -> None
gluTessVertex( tess,location,data )
pyConverters: tess=None, location=<OpenGL.converters.CallFuncPyConverter object at 0x8b65a8c>, data=None
cConverters: tess=None, location=<OpenGL.converters.getPyArgsName object at 0x87b4e14>, data=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: gluTessVertex( POINTER(GLUtesselator)(tess), arrays.GLdoubleArray(location), POINTER(GLvoid)(data) ) -> None
gluUnProject( winX,winY,winZ,model,proj,view,objX,objY,objZ )
pyConverters: winX=None, winY=None, winZ=None, model=<OpenGL.converters.CallFuncPyConverter object at 0x8b65a2c>, proj=<OpenGL.converters.CallFuncPyConverter object at 0x8b65cec>, view=<OpenGL.converters.CallFuncPyConverter object at 0x8b65d0c>, objX=<OpenGL.converters.CallFuncPyConverter object at 0x8b65d4c>, objY=<OpenGL.converters.CallFuncPyConverter object at 0x8b65d8c>, objZ=<OpenGL.converters.CallFuncPyConverter object at 0x8b65dcc>
cConverters: winX=None, winY=None, winZ=None, model=<OpenGL.converters.getPyArgsName object at 0x87b4eb4>, proj=<OpenGL.converters.getPyArgsName object at 0x87b4f04>, view=<OpenGL.converters.getPyArgsName object at 0x87b4f54>, objX=<OpenGL.converters.getPyArgsName object at 0x87b4fa4>, objY=<OpenGL.converters.getPyArgsName object at 0x87b702c>, objZ=<OpenGL.converters.getPyArgsName object at 0x87b707c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: gluUnProject( GLdouble(winX), GLdouble(winY), GLdouble(winZ), arrays.GLdoubleArray(model), arrays.GLdoubleArray(proj), arrays.GLintArray(view), arrays.GLdoubleArray(objX), arrays.GLdoubleArray(objY), arrays.GLdoubleArray(objZ) ) -> GLint
gluUnProject4( winX,winY,winZ,clipW,model,proj,view,nearVal,farVal,objX,objY,objZ,objW )
pyConverters: winX=None, winY=None, winZ=None, clipW=None, model=<OpenGL.converters.CallFuncPyConverter object at 0x8b65e4c>, proj=<OpenGL.converters.CallFuncPyConverter object at 0x8b65f0c>, view=<OpenGL.converters.CallFuncPyConverter object at 0x8b65f2c>, nearVal=None, farVal=None, objX=<OpenGL.converters.CallFuncPyConverter object at 0x8b65f6c>, objY=<OpenGL.converters.CallFuncPyConverter object at 0x8b65fac>, objZ=<OpenGL.converters.CallFuncPyConverter object at 0x8b65fec>, objW=<OpenGL.converters.CallFuncPyConverter object at 0x87b604c>
cConverters: winX=None, winY=None, winZ=None, clipW=None, model=<OpenGL.converters.getPyArgsName object at 0x87b711c>, proj=<OpenGL.converters.getPyArgsName object at 0x87b716c>, view=<OpenGL.converters.getPyArgsName object at 0x87b71bc>, nearVal=None, farVal=None, objX=<OpenGL.converters.getPyArgsName object at 0x87b720c>, objY=<OpenGL.converters.getPyArgsName object at 0x87b725c>, objZ=<OpenGL.converters.getPyArgsName object at 0x87b72ac>, objW=<OpenGL.converters.getPyArgsName object at 0x87b72fc>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: gluUnProject4( GLdouble(winX), GLdouble(winY), GLdouble(winZ), GLdouble(clipW), arrays.GLdoubleArray(model), arrays.GLdoubleArray(proj), arrays.GLintArray(view), GLdouble(nearVal), GLdouble(farVal), arrays.GLdoubleArray(objX), arrays.GLdoubleArray(objY), arrays.GLdoubleArray(objZ), arrays.GLdoubleArray(objW) ) -> GLint
memmove = <CFunctionType object at 0x4022bf9c> memset = <CFunctionType object at 0x835202c>
resize(...)
Resize the memory buffer of a ctypes instance
set_conversion_mode(...)
set_conversion_mode(encoding, errors) -> (previous-encoding, previous-errors)
 
Set the encoding and error handling ctypes uses when converting
between unicode and strings.  Returns the previous values.
sizeof(...)
sizeof(C type) -> integer
sizeof(C instance) -> integer
Return the size in bytes of a C instance

 
Data
        DEFAULT_MODE = 0
GLvoid = None
RTLD_GLOBAL = 256
RTLD_LOCAL = 0
__all__ = ['gluCheckExtension', 'gluGetNurbsProperty', 'gluGetTessProperty', 'gluLoadSamplingMatrices', 'gluNurbsCurve', 'gluNurbsSurface', 'gluPickMatrix', 'gluProject', 'gluPwlCurve', 'gluTessVertex', 'gluUnProject', 'gluUnProject4']
__file__ = '/build/buildd/pyopengl-3.0.0~b3/OpenGL/raw/GLU/annotations.py'
__name__ = 'OpenGL.raw.GLU.annotations'
cdll = <ctypes.LibraryLoader object at 0x835146c>
pydll = <ctypes.LibraryLoader object at 0x835148c>
pythonapi = <PyDLL 'None', handle 4001c668 at 83514ac>