OpenGL.raw.GLU.annotations
index
/build/buildd/pyopengl-3.0.0~b6/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 0x879602c>, extString=<OpenGL.converters.CallFuncPyConverter object at 0x87965cc>
cConverters: extName=<OpenGL.converters.getPyArgsName object at 0x8551dc4>, extString=<OpenGL.converters.getPyArgsName object at 0x8551e14>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x82a20cc>
cConverters: nurb=None, property=None, data=<OpenGL.converters.getPyArgsName object at 0x8551e8c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x82a22ac>
cConverters: tess=None, which=None, data=<OpenGL.converters.getPyArgsName object at 0x8551f04>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x82a252c>, perspective=<OpenGL.converters.CallFuncPyConverter object at 0x82a25ac>, view=<OpenGL.converters.CallFuncPyConverter object at 0x82a25cc>
cConverters: nurb=None, model=<OpenGL.converters.getPyArgsName object at 0x8551f7c>, perspective=<OpenGL.converters.getPyArgsName object at 0x8551fcc>, view=<OpenGL.converters.getPyArgsName object at 0x8557054>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x82a264c>, stride=None, control=<OpenGL.converters.CallFuncPyConverter object at 0x82a26cc>, order=None, type=None
cConverters: nurb=None, knotCount=None, knots=<OpenGL.converters.getPyArgsName object at 0x85570cc>, stride=None, control=<OpenGL.converters.getPyArgsName object at 0x855711c>, 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 0x82a272c>, tKnotCount=None, tKnots=<OpenGL.converters.CallFuncPyConverter object at 0x82a27ac>, sStride=None, tStride=None, control=<OpenGL.converters.CallFuncPyConverter object at 0x82a27cc>, sOrder=None, tOrder=None, type=None
cConverters: nurb=None, sKnotCount=None, sKnots=<OpenGL.converters.getPyArgsName object at 0x8557194>, tKnotCount=None, tKnots=<OpenGL.converters.getPyArgsName object at 0x85571e4>, sStride=None, tStride=None, control=<OpenGL.converters.getPyArgsName object at 0x8557234>, 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 0x82a284c>
cConverters: x=None, y=None, delX=None, delY=None, viewport=<OpenGL.converters.getPyArgsName object at 0x85572ac>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x82a28ec>, proj=<OpenGL.converters.CallFuncPyConverter object at 0x82a296c>, view=<OpenGL.converters.CallFuncPyConverter object at 0x82a298c>, winX=<OpenGL.converters.CallFuncPyConverter object at 0x82a29cc>, winY=<OpenGL.converters.CallFuncPyConverter object at 0x82a2a0c>, winZ=<OpenGL.converters.CallFuncPyConverter object at 0x82a2a4c>
cConverters: objX=None, objY=None, objZ=None, model=<OpenGL.converters.getPyArgsName object at 0x8557324>, proj=<OpenGL.converters.getPyArgsName object at 0x8557374>, view=<OpenGL.converters.getPyArgsName object at 0x85573c4>, winX=<OpenGL.converters.getPyArgsName object at 0x8557414>, winY=<OpenGL.converters.getPyArgsName object at 0x8557464>, winZ=<OpenGL.converters.getPyArgsName object at 0x85574b4>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x82a2acc>, stride=None, type=None
cConverters: nurb=None, count=None, data=<OpenGL.converters.getPyArgsName object at 0x855752c>, 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 0x82a2b6c>, data=None
cConverters: tess=None, location=<OpenGL.converters.getPyArgsName object at 0x85575cc>, 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 0x82a2c0c>, proj=<OpenGL.converters.CallFuncPyConverter object at 0x82a2ccc>, view=<OpenGL.converters.CallFuncPyConverter object at 0x82a2cec>, objX=<OpenGL.converters.CallFuncPyConverter object at 0x82a2d2c>, objY=<OpenGL.converters.CallFuncPyConverter object at 0x82a2d6c>, objZ=<OpenGL.converters.CallFuncPyConverter object at 0x82a2dac>
cConverters: winX=None, winY=None, winZ=None, model=<OpenGL.converters.getPyArgsName object at 0x855766c>, proj=<OpenGL.converters.getPyArgsName object at 0x85576bc>, view=<OpenGL.converters.getPyArgsName object at 0x855770c>, objX=<OpenGL.converters.getPyArgsName object at 0x855775c>, objY=<OpenGL.converters.getPyArgsName object at 0x85577ac>, objZ=<OpenGL.converters.getPyArgsName object at 0x85577fc>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x82a2e2c>, proj=<OpenGL.converters.CallFuncPyConverter object at 0x82a2eec>, view=<OpenGL.converters.CallFuncPyConverter object at 0x82a2f0c>, nearVal=None, farVal=None, objX=<OpenGL.converters.CallFuncPyConverter object at 0x82a2f4c>, objY=<OpenGL.converters.CallFuncPyConverter object at 0x82a2f8c>, objZ=<OpenGL.converters.CallFuncPyConverter object at 0x82a2fcc>, objW=<OpenGL.converters.CallFuncPyConverter object at 0x855902c>
cConverters: winX=None, winY=None, winZ=None, clipW=None, model=<OpenGL.converters.getPyArgsName object at 0x855789c>, proj=<OpenGL.converters.getPyArgsName object at 0x85578ec>, view=<OpenGL.converters.getPyArgsName object at 0x855793c>, nearVal=None, farVal=None, objX=<OpenGL.converters.getPyArgsName object at 0x855798c>, objY=<OpenGL.converters.getPyArgsName object at 0x85579dc>, objZ=<OpenGL.converters.getPyArgsName object at 0x8557a2c>, objW=<OpenGL.converters.getPyArgsName object at 0x8557a7c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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 0x835602c> memset = <CFunctionType object at 0x8356094>
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~b6/OpenGL/raw/GLU/annotations.py'
__name__ = 'OpenGL.raw.GLU.annotations'
cdll = <ctypes.LibraryLoader object at 0x8353a2c>
pydll = <ctypes.LibraryLoader object at 0x8353a4c>
pythonapi = <PyDLL 'None', handle 4001d670 at 8353a6c>