OpenGL.GLE.__init__
index
/var/pylive/OpenGL-ctypes/OpenGL/GLE/__init__.py

GL Extrusion Routine Library (GLE) wrapper for OpenGL-ctypes

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

 
Functions
        gleExtrusion( contour,cont_normal,up,point_array,color_array )
pyConverters: contour=<OpenGL.converters.CallFuncPyConverter object>, cont_normal=<OpenGL.converters.CallFuncPyConverter object>, up=<OpenGL.converters.CallFuncPyConverter object>, point_array=<OpenGL.converters.CallFuncPyConverter object>, color_array=<OpenGL.converters.CallFuncPyConverter object>
cConverters: ncp=<OpenGL.GLE.exceptional._lengthOfArgname object>, contour=<OpenGL.converters.getPyArgsName object>, cont_normal=<OpenGL.converters.getPyArgsName object>, up=<OpenGL.converters.getPyArgsName object>, npoints=<OpenGL.GLE.exceptional._lengthOfArgname object>, point_array=<OpenGL.converters.getPyArgsName object>, color_array=<OpenGL.converters.getPyArgsName object>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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
gleGetJoinStyle(...)
gleGetJoinStyle(  ) -> c_int
gleGetNumSides(...)
gleGetNumSides(  ) -> c_int
gleHelicoid( rToroid,startRadius,drdTheta,startZ,dzdTheta,startXform,dXformdTheta,startTheta,sweepTheta )
pyConverters: rToroid=None, startRadius=None, drdTheta=None, startZ=None, dzdTheta=None, startXform=<OpenGL.converters.CallFuncPyConverter object>, dXformdTheta=<OpenGL.converters.CallFuncPyConverter object>, startTheta=None, sweepTheta=None
cConverters: rToroid=None, startRadius=None, drdTheta=None, startZ=None, dzdTheta=None, startXform=<OpenGL.converters.getPyArgsName object>, dXformdTheta=<OpenGL.converters.getPyArgsName object>, 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: gleHelicoid( gleDouble(rToroid), gleDouble(startRadius), gleDouble(drdTheta), gleDouble(startZ), gleDouble(dzdTheta), arrays.GLdoubleArray(startXform), arrays.GLdoubleArray(dXformdTheta), gleDouble(startTheta), gleDouble(sweepTheta) ) -> None
gleLathe( contour,cont_normal,up,startRadius,drdTheta,startZ,dzdTheta,startXform,dXformdTheta,startTheta,sweepTheta )
pyConverters: contour=<OpenGL.converters.CallFuncPyConverter object>, cont_normal=<OpenGL.converters.CallFuncPyConverter object>, up=<OpenGL.converters.CallFuncPyConverter object>, startRadius=None, drdTheta=None, startZ=None, dzdTheta=None, startXform=<OpenGL.converters.CallFuncPyConverter object>, dXformdTheta=<OpenGL.converters.CallFuncPyConverter object>, startTheta=None, sweepTheta=None
cConverters: ncp=<OpenGL.GLE.exceptional._lengthOfArgname object>, contour=<OpenGL.converters.getPyArgsName object>, cont_normal=<OpenGL.converters.getPyArgsName object>, up=<OpenGL.converters.getPyArgsName object>, startRadius=None, drdTheta=None, startZ=None, dzdTheta=None, startXform=<OpenGL.converters.getPyArgsName object>, dXformdTheta=<OpenGL.converters.getPyArgsName object>, 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>, color_array=<OpenGL.converters.CallFuncPyConverter object>, radius_array=<OpenGL.converters.CallFuncPyConverter object>
cConverters: npoints=<OpenGL.GLE.exceptional._lengthOfArgname object>, point_array=<OpenGL.converters.getPyArgsName object>, color_array=<OpenGL.converters.getPyArgsName object>, radius_array=<OpenGL.converters.getPyArgsName object>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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>, color_array=<OpenGL.converters.CallFuncPyConverter object>, radius=None
cConverters: npoints=<OpenGL.GLE.exceptional._lengthOfArgname object>, point_array=<OpenGL.converters.getPyArgsName object>, color_array=<OpenGL.converters.getPyArgsName object>, 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>, cont_normal=<OpenGL.converters.CallFuncPyConverter object>, up=<OpenGL.converters.CallFuncPyConverter object>, startz=None, endz=None, twist=None
cConverters: ncp=<OpenGL.GLE.exceptional._lengthOfArgname object>, contour=<OpenGL.converters.getPyArgsName object>, cont_normal=<OpenGL.converters.getPyArgsName object>, up=<OpenGL.converters.getPyArgsName object>, 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
gleSetJoinStyle(...)
gleSetJoinStyle( c_int(style) ) -> None
gleSetNumSides(...)
gleSetNumSides( c_int(slices) ) -> None
gleSpiral( contour,cont_normal,up,startRadius,drdTheta,startZ,dzdTheta,startXform,dXformdTheta,startTheta,sweepTheta )
pyConverters: contour=<OpenGL.converters.CallFuncPyConverter object>, cont_normal=<OpenGL.converters.CallFuncPyConverter object>, up=<OpenGL.converters.CallFuncPyConverter object>, startRadius=None, drdTheta=None, startZ=None, dzdTheta=None, startXform=<OpenGL.converters.CallFuncPyConverter object>, dXformdTheta=<OpenGL.converters.CallFuncPyConverter object>, startTheta=None, sweepTheta=None
cConverters: ncp=<OpenGL.GLE.exceptional._lengthOfArgname object>, contour=<OpenGL.converters.getPyArgsName object>, cont_normal=<OpenGL.converters.getPyArgsName object>, up=<OpenGL.converters.getPyArgsName object>, startRadius=None, drdTheta=None, startZ=None, dzdTheta=None, startXform=<OpenGL.converters.getPyArgsName object>, dXformdTheta=<OpenGL.converters.getPyArgsName object>, 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>, cont_normal=<OpenGL.converters.CallFuncPyConverter object>, up=<OpenGL.converters.CallFuncPyConverter object>, point_array=<OpenGL.converters.CallFuncPyConverter object>, color_array=<OpenGL.converters.CallFuncPyConverter object>, xform_array=<OpenGL.converters.CallFuncPyConverter object>
cConverters: ncp=<OpenGL.GLE.exceptional._lengthOfArgname object>, contour=<OpenGL.converters.getPyArgsName object>, cont_normal=<OpenGL.converters.getPyArgsName object>, up=<OpenGL.converters.getPyArgsName object>, npoints=<OpenGL.GLE.exceptional._lengthOfArgname object>, point_array=<OpenGL.converters.getPyArgsName object>, color_array=<OpenGL.converters.getPyArgsName object>, xform_array=<OpenGL.converters.getPyArgsName object>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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
gleTextureMode(...)
gleTextureMode( c_int(mode) ) -> None
gleToroid( rToroid,startRadius,drdTheta,startZ,dzdTheta,startXform,dXformdTheta,startTheta,sweepTheta )
pyConverters: rToroid=None, startRadius=None, drdTheta=None, startZ=None, dzdTheta=None, startXform=<OpenGL.converters.CallFuncPyConverter object>, dXformdTheta=<OpenGL.converters.CallFuncPyConverter object>, startTheta=None, sweepTheta=None
cConverters: rToroid=None, startRadius=None, drdTheta=None, startZ=None, dzdTheta=None, startXform=<OpenGL.converters.getPyArgsName object>, dXformdTheta=<OpenGL.converters.getPyArgsName object>, 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: gleToroid( gleDouble(rToroid), gleDouble(startRadius), gleDouble(drdTheta), gleDouble(startZ), gleDouble(dzdTheta), arrays.GLdoubleArray(startXform), arrays.GLdoubleArray(dXformdTheta), gleDouble(startTheta), gleDouble(sweepTheta) ) -> None
gleTwistExtrusion( contour,cont_normal,up,point_array,color_array,twist_array )
pyConverters: contour=<OpenGL.converters.CallFuncPyConverter object>, cont_normal=<OpenGL.converters.CallFuncPyConverter object>, up=<OpenGL.converters.CallFuncPyConverter object>, point_array=<OpenGL.converters.CallFuncPyConverter object>, color_array=<OpenGL.converters.CallFuncPyConverter object>, twist_array=<OpenGL.converters.CallFuncPyConverter object>
cConverters: ncp=<OpenGL.GLE.exceptional._lengthOfArgname object>, contour=<OpenGL.converters.getPyArgsName object>, cont_normal=<OpenGL.converters.getPyArgsName object>, up=<OpenGL.converters.getPyArgsName object>, npoints=<OpenGL.GLE.exceptional._lengthOfArgname object>, point_array=<OpenGL.converters.getPyArgsName object>, color_array=<OpenGL.converters.getPyArgsName object>, twist_array=<OpenGL.converters.getPyArgsName object>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(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
rot_about_axis( angle,axis )
pyConverters: angle=None, axis=<OpenGL.converters.CallFuncPyConverter object>
cConverters: angle=None, axis=<OpenGL.converters.getPyArgsName object>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: rot_about_axis( gleDouble(angle), arrays.GLdoubleArray(axis) ) -> None
rot_axis( omega,axis )
pyConverters: omega=None, axis=<OpenGL.converters.CallFuncPyConverter object>
cConverters: omega=None, axis=<OpenGL.converters.getPyArgsName object>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: rot_axis( gleDouble(omega), arrays.GLdoubleArray(axis) ) -> None
rot_omega( axis )
pyConverters: axis=<OpenGL.converters.CallFuncPyConverter object>
cConverters: axis=<OpenGL.converters.getPyArgsName object>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: rot_omega( arrays.GLdoubleArray(axis) ) -> None
rot_prince(...)
rot_prince( gleDouble(omega), c_char(axis) ) -> None
urot_about_axis( m,angle,axis )
pyConverters: m=<OpenGL.converters.CallFuncPyConverter object>, angle=None, axis=<OpenGL.converters.CallFuncPyConverter object>
cConverters: m=<OpenGL.converters.getPyArgsName object>, angle=None, axis=<OpenGL.converters.getPyArgsName object>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: urot_about_axis( arrays.GLdoubleArray(m), gleDouble(angle), arrays.GLdoubleArray(axis) ) -> None
urot_axis( m,omega,axis )
pyConverters: m=<OpenGL.converters.CallFuncPyConverter object>, omega=None, axis=<OpenGL.converters.CallFuncPyConverter object>
cConverters: m=<OpenGL.converters.getPyArgsName object>, omega=None, axis=<OpenGL.converters.getPyArgsName object>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: urot_axis( arrays.GLdoubleArray(m), gleDouble(omega), arrays.GLdoubleArray(axis) ) -> None
urot_omega( m,axis )
pyConverters: m=<OpenGL.converters.CallFuncPyConverter object>, axis=<OpenGL.converters.CallFuncPyConverter object>
cConverters: m=<OpenGL.converters.getPyArgsName object>, axis=<OpenGL.converters.getPyArgsName object>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: urot_omega( arrays.GLdoubleArray(m), arrays.GLdoubleArray(axis) ) -> None
urot_prince( m,omega,axis )
pyConverters: m=<OpenGL.converters.CallFuncPyConverter object>, omega=None, axis=None
cConverters: m=<OpenGL.converters.getPyArgsName object>, omega=None, axis=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: urot_prince( arrays.GLdoubleArray(m), gleDouble(omega), c_char(axis) ) -> None
uview_direction( m,v21,up )
pyConverters: m=<OpenGL.converters.CallFuncPyConverter object>, v21=<OpenGL.converters.CallFuncPyConverter object>, up=<OpenGL.converters.CallFuncPyConverter object>
cConverters: m=<OpenGL.converters.getPyArgsName object>, v21=<OpenGL.converters.getPyArgsName object>, up=<OpenGL.converters.getPyArgsName object>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: uview_direction( arrays.GLdoubleArray(m), arrays.GLdoubleArray(v21), arrays.GLdoubleArray(up) ) -> None
uviewpoint( m,v1,v2,up )
pyConverters: m=<OpenGL.converters.CallFuncPyConverter object>, v1=<OpenGL.converters.CallFuncPyConverter object>, v2=<OpenGL.converters.CallFuncPyConverter object>, up=<OpenGL.converters.CallFuncPyConverter object>
cConverters: m=<OpenGL.converters.getPyArgsName object>, v1=<OpenGL.converters.getPyArgsName object>, v2=<OpenGL.converters.getPyArgsName object>, up=<OpenGL.converters.getPyArgsName object>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: uviewpoint( arrays.GLdoubleArray(m), arrays.GLdoubleArray(v1), arrays.GLdoubleArray(v2), arrays.GLdoubleArray(up) ) -> None

 
Data
        GLE_TEXTURE_ENABLE = GLE_TEXTURE_ENABLE
GLE_TEXTURE_NORMAL_CYL = GLE_TEXTURE_NORMAL_CYL
GLE_TEXTURE_NORMAL_FLAT = GLE_TEXTURE_NORMAL_FLAT
GLE_TEXTURE_NORMAL_MODEL_CYL = GLE_TEXTURE_NORMAL_MODEL_CYL
GLE_TEXTURE_NORMAL_MODEL_FLAT = GLE_TEXTURE_NORMAL_MODEL_FLAT
GLE_TEXTURE_NORMAL_MODEL_SPH = GLE_TEXTURE_NORMAL_MODEL_SPH
GLE_TEXTURE_NORMAL_SPH = GLE_TEXTURE_NORMAL_SPH
GLE_TEXTURE_STYLE_MASK = GLE_TEXTURE_STYLE_MASK
GLE_TEXTURE_VERTEX_CYL = GLE_TEXTURE_VERTEX_CYL
GLE_TEXTURE_VERTEX_FLAT = GLE_TEXTURE_VERTEX_FLAT
GLE_TEXTURE_VERTEX_MODEL_CYL = GLE_TEXTURE_VERTEX_MODEL_CYL
GLE_TEXTURE_VERTEX_MODEL_FLAT = GLE_TEXTURE_VERTEX_MODEL_FLAT
GLE_TEXTURE_VERTEX_MODEL_SPH = GLE_TEXTURE_VERTEX_MODEL_SPH
GLE_TEXTURE_VERTEX_SPH = GLE_TEXTURE_VERTEX_SPH
TUBE_CONTOUR_CLOSED = TUBE_CONTOUR_CLOSED
TUBE_JN_ANGLE = TUBE_JN_ANGLE
TUBE_JN_CAP = TUBE_JN_CAP
TUBE_JN_CUT = TUBE_JN_CUT
TUBE_JN_MASK = TUBE_JN_MASK
TUBE_JN_RAW = TUBE_JN_RAW
TUBE_JN_ROUND = TUBE_JN_ROUND
TUBE_NORM_EDGE = TUBE_NORM_EDGE
TUBE_NORM_FACET = TUBE_NORM_FACET
TUBE_NORM_MASK = TUBE_NORM_MASK
TUBE_NORM_PATH_EDGE = TUBE_NORM_PATH_EDGE
__GLE_DOUBLE = __GLE_DOUBLE