OpenGL.GLE.exceptional
index
/var/pylive/src/OpenGL-dev/OpenGL-ctypes/OpenGL/GLE/exceptional.py

GLE exceptional functions (specialised signatures

 
Modules
       
OpenGL.arrays
OpenGL.raw.GLE
OpenGL.raw.GLE.annotations
OpenGL.wrapper

 
Classes
       
object
_lengthOfArgname

 
class _lengthOfArgname(object)
    Calculates the length of a given argname over a divisor value
 
  Methods defined here:
__call__(self, pyArgs, index, wrappedOperation)
Get the length of pyArgs[2], a glDoubleArray
__init__(self, arrayName, divisor, arrayType=<class 'OpenGL.arrays.arraydatatype.GLdoubleArray'>)
finalise(self, wrapper)

Data descriptors defined here:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
Functions
       
_baseWrap(base, lengthName='ncp', contourName='contour', divisor=2)
Do the basic wrapping operation for a GLE function
gleExtrusion( contour,cont_normal,up,point_array,color_array )
pyConverters: contour=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab29a2410>, cont_normal=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab29a2490>, up=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab29a24d0>, point_array=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab29a2510>, color_array=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab29a2550>
cConverters: ncp=<OpenGL.GLE.exceptional._lengthOfArgname object at 0x2aaab29addd0>, contour=<OpenGL.converters.getPyArgsName object at 0x2aaab29aa320>, cont_normal=<OpenGL.converters.getPyArgsName object at 0x2aaab29aa3c0>, up=<OpenGL.converters.getPyArgsName object at 0x2aaab29aa460>, npoints=<OpenGL.GLE.exceptional._lengthOfArgname object at 0x2aaab29ade10>, point_array=<OpenGL.converters.getPyArgsName object at 0x2aaab29aa500>, color_array=<OpenGL.converters.getPyArgsName object at 0x2aaab29aa5a0>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: gleExtrusion( c_int(ncp), arrays.GLdoubleArray(contour), arrays.GLdoubleArray(cont_normal), arrays.GLdoubleArray(up), c_int(npoints), arrays.GLdoubleArray(point_array), arrays.GLfloatArray(color_array) ) -> None
gleLathe( contour,cont_normal,up,startRadius,drdTheta,startZ,dzdTheta,startXform,dXformdTheta,startTheta,sweepTheta )
pyConverters: contour=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab29a2690>, cont_normal=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab29a2750>, up=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab29a2790>, startRadius=None, drdTheta=None, startZ=None, dzdTheta=None, startXform=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab29a27d0>, dXformdTheta=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab29a2810>, startTheta=None, sweepTheta=None
cConverters: ncp=<OpenGL.GLE.exceptional._lengthOfArgname object at 0x2aaab29adc90>, contour=<OpenGL.converters.getPyArgsName object at 0x2aaab29aa780>, cont_normal=<OpenGL.converters.getPyArgsName object at 0x2aaab29aa820>, up=<OpenGL.converters.getPyArgsName object at 0x2aaab29aa8c0>, startRadius=None, drdTheta=None, startZ=None, dzdTheta=None, startXform=<OpenGL.converters.getPyArgsName object at 0x2aaab29aa960>, dXformdTheta=<OpenGL.converters.getPyArgsName object at 0x2aaab29aaa00>, startTheta=None, sweepTheta=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: gleLathe( c_int(ncp), arrays.GLdoubleArray(contour), arrays.GLdoubleArray(cont_normal), arrays.GLdoubleArray(up), gleDouble(startRadius), gleDouble(drdTheta), gleDouble(startZ), gleDouble(dzdTheta), arrays.GLdoubleArray(startXform), arrays.GLdoubleArray(dXformdTheta), gleDouble(startTheta), gleDouble(sweepTheta) ) -> None
glePolyCone( point_array,color_array,radius_array )
pyConverters: point_array=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab29a2850>, color_array=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab29a2910>, radius_array=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab29a2950>
cConverters: npoints=<OpenGL.GLE.exceptional._lengthOfArgname object at 0x2aaab29adcd0>, point_array=<OpenGL.converters.getPyArgsName object at 0x2aaab29aaaa0>, color_array=<OpenGL.converters.getPyArgsName object at 0x2aaab29aab40>, radius_array=<OpenGL.converters.getPyArgsName object at 0x2aaab29aabe0>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glePolyCone( c_int(npoints), arrays.GLdoubleArray(point_array), arrays.GLfloatArray(color_array), arrays.GLdoubleArray(radius_array) ) -> None
glePolyCylinder( point_array,color_array,radius )
pyConverters: point_array=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab29a2990>, color_array=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab29a2a50>, radius=None
cConverters: npoints=<OpenGL.GLE.exceptional._lengthOfArgname object at 0x2aaab29add10>, point_array=<OpenGL.converters.getPyArgsName object at 0x2aaab29aac80>, color_array=<OpenGL.converters.getPyArgsName object at 0x2aaab29aad20>, radius=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: glePolyCylinder( c_int(npoints), arrays.GLdoubleArray(point_array), arrays.GLfloatArray(color_array), gleDouble(radius) ) -> None
gleScrew( contour,cont_normal,up,startz,endz,twist )
pyConverters: contour=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab29a2a90>, cont_normal=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab29a2b50>, up=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab29a2b90>, startz=None, endz=None, twist=None
cConverters: ncp=<OpenGL.GLE.exceptional._lengthOfArgname object at 0x2aaab29add50>, contour=<OpenGL.converters.getPyArgsName object at 0x2aaab29aae10>, cont_normal=<OpenGL.converters.getPyArgsName object at 0x2aaab29aaeb0>, up=<OpenGL.converters.getPyArgsName object at 0x2aaab29aaf50>, startz=None, endz=None, twist=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: gleScrew( c_int(ncp), arrays.GLdoubleArray(contour), arrays.GLdoubleArray(cont_normal), arrays.GLdoubleArray(up), gleDouble(startz), gleDouble(endz), gleDouble(twist) ) -> None
gleSpiral( contour,cont_normal,up,startRadius,drdTheta,startZ,dzdTheta,startXform,dXformdTheta,startTheta,sweepTheta )
pyConverters: contour=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab29a2bd0>, cont_normal=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab29a2c90>, up=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab29a2cd0>, startRadius=None, drdTheta=None, startZ=None, dzdTheta=None, startXform=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab29a2d10>, dXformdTheta=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab29a2d50>, startTheta=None, sweepTheta=None
cConverters: ncp=<OpenGL.GLE.exceptional._lengthOfArgname object at 0x2aaab29add90>, contour=<OpenGL.converters.getPyArgsName object at 0x2aaab29ab0a0>, cont_normal=<OpenGL.converters.getPyArgsName object at 0x2aaab29ab140>, up=<OpenGL.converters.getPyArgsName object at 0x2aaab29ab1e0>, startRadius=None, drdTheta=None, startZ=None, dzdTheta=None, startXform=<OpenGL.converters.getPyArgsName object at 0x2aaab29ab280>, dXformdTheta=<OpenGL.converters.getPyArgsName object at 0x2aaab29ab320>, startTheta=None, sweepTheta=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: gleSpiral( c_int(ncp), arrays.GLdoubleArray(contour), arrays.GLdoubleArray(cont_normal), arrays.GLdoubleArray(up), gleDouble(startRadius), gleDouble(drdTheta), gleDouble(startZ), gleDouble(dzdTheta), arrays.GLdoubleArray(startXform), arrays.GLdoubleArray(dXformdTheta), gleDouble(startTheta), gleDouble(sweepTheta) ) -> None
gleSuperExtrusion( contour,cont_normal,up,point_array,color_array,xform_array )
pyConverters: contour=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab29a2d90>, cont_normal=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab29a2e50>, up=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab29a2e90>, point_array=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab29a2ed0>, color_array=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab29a2f10>, xform_array=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab29a2f50>
cConverters: ncp=<OpenGL.GLE.exceptional._lengthOfArgname object at 0x2aaab29ade50>, contour=<OpenGL.converters.getPyArgsName object at 0x2aaab29ab410>, cont_normal=<OpenGL.converters.getPyArgsName object at 0x2aaab29ab4b0>, up=<OpenGL.converters.getPyArgsName object at 0x2aaab29ab550>, npoints=<OpenGL.GLE.exceptional._lengthOfArgname object at 0x2aaab29ade90>, point_array=<OpenGL.converters.getPyArgsName object at 0x2aaab29ab5f0>, color_array=<OpenGL.converters.getPyArgsName object at 0x2aaab29ab690>, xform_array=<OpenGL.converters.getPyArgsName object at 0x2aaab29ab730>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: gleSuperExtrusion( c_int(ncp), arrays.GLdoubleArray(contour), arrays.GLdoubleArray(cont_normal), arrays.GLdoubleArray(up), c_int(npoints), arrays.GLdoubleArray(point_array), arrays.GLfloatArray(color_array), arrays.GLdoubleArray(xform_array) ) -> None
gleTwistExtrusion( contour,cont_normal,up,point_array,color_array,twist_array )
pyConverters: contour=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab29ad0d0>, cont_normal=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab29ad190>, up=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab29ad1d0>, point_array=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab29ad210>, color_array=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab29ad250>, twist_array=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab29ad290>
cConverters: ncp=<OpenGL.GLE.exceptional._lengthOfArgname object at 0x2aaab29aded0>, contour=<OpenGL.converters.getPyArgsName object at 0x2aaab29ab9b0>, cont_normal=<OpenGL.converters.getPyArgsName object at 0x2aaab29aba50>, up=<OpenGL.converters.getPyArgsName object at 0x2aaab29abaf0>, npoints=<OpenGL.GLE.exceptional._lengthOfArgname object at 0x2aaab29adf10>, point_array=<OpenGL.converters.getPyArgsName object at 0x2aaab29abb90>, color_array=<OpenGL.converters.getPyArgsName object at 0x2aaab29abc30>, twist_array=<OpenGL.converters.getPyArgsName object at 0x2aaab29abcd0>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: gleTwistExtrusion( c_int(ncp), arrays.GLdoubleArray(contour), arrays.GLdoubleArray(cont_normal), arrays.GLdoubleArray(up), c_int(npoints), arrays.GLdoubleArray(point_array), arrays.GLfloatArray(color_array), arrays.GLdoubleArray(twist_array) ) -> None