| | |
- 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
gleExtrusion( contour,cont_normal,up,point_array,color_array )
pyConverters: contour=<OpenGL.converters.CallFuncPyConverter object at 0x8e8286c>, cont_normal=<OpenGL.converters.CallFuncPyConverter object at 0x8e82d2c>, up=<OpenGL.converters.CallFuncPyConverter object at 0x8e8276c>, point_array=<OpenGL.converters.CallFuncPyConverter object at 0x8e827ec>, color_array=<OpenGL.converters.CallFuncPyConverter object at 0x8e8284c>
cConverters: ncp=<OpenGL.GLE.exceptional._lengthOfArgname object at 0x8e84cec>, contour=<OpenGL.converters.getPyArgsName object at 0x8d117d4>, cont_normal=<OpenGL.converters.getPyArgsName object at 0x8d11824>, up=<OpenGL.converters.getPyArgsName object at 0x8d11874>, npoints=<OpenGL.GLE.exceptional._lengthOfArgname object at 0x8e84b2c>, point_array=<OpenGL.converters.getPyArgsName object at 0x8d118c4>, color_array=<OpenGL.converters.getPyArgsName object at 0x8d11914>
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
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 at 0x8e820cc>, dXformdTheta=<OpenGL.converters.CallFuncPyConverter object at 0x8e8208c>, startTheta=None, sweepTheta=None
cConverters: rToroid=None, startRadius=None, drdTheta=None, startZ=None, dzdTheta=None, startXform=<OpenGL.converters.getPyArgsName object at 0x8d1198c>, dXformdTheta=<OpenGL.converters.getPyArgsName object at 0x8d119dc>, 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 at 0x8e822ac>, cont_normal=<OpenGL.converters.CallFuncPyConverter object at 0x8e82ccc>, up=<OpenGL.converters.CallFuncPyConverter object at 0x8e8250c>, startRadius=None, drdTheta=None, startZ=None, dzdTheta=None, startXform=<OpenGL.converters.CallFuncPyConverter object at 0x8e8244c>, dXformdTheta=<OpenGL.converters.CallFuncPyConverter object at 0x8e82e8c>, startTheta=None, sweepTheta=None
cConverters: ncp=<OpenGL.GLE.exceptional._lengthOfArgname object at 0x8e8426c>, contour=<OpenGL.converters.getPyArgsName object at 0x8d11a54>, cont_normal=<OpenGL.converters.getPyArgsName object at 0x8d11aa4>, up=<OpenGL.converters.getPyArgsName object at 0x8d11af4>, startRadius=None, drdTheta=None, startZ=None, dzdTheta=None, startXform=<OpenGL.converters.getPyArgsName object at 0x8d11b44>, dXformdTheta=<OpenGL.converters.getPyArgsName object at 0x8d11b94>, 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 0x8e82bcc>, color_array=<OpenGL.converters.CallFuncPyConverter object at 0x8e8206c>, radius_array=<OpenGL.converters.CallFuncPyConverter object at 0x8e821cc>
cConverters: npoints=<OpenGL.GLE.exceptional._lengthOfArgname object at 0x8e8472c>, point_array=<OpenGL.converters.getPyArgsName object at 0x8d11c0c>, color_array=<OpenGL.converters.getPyArgsName object at 0x8d11c5c>, radius_array=<OpenGL.converters.getPyArgsName object at 0x8d11cac>
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 0x8e82d8c>, color_array=<OpenGL.converters.CallFuncPyConverter object at 0x8ddf4ac>, radius=None
cConverters: npoints=<OpenGL.GLE.exceptional._lengthOfArgname object at 0x8e84bcc>, point_array=<OpenGL.converters.getPyArgsName object at 0x8d11d24>, color_array=<OpenGL.converters.getPyArgsName object at 0x8d11d74>, 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 0x8ddfc8c>, cont_normal=<OpenGL.converters.CallFuncPyConverter object at 0x8ddf94c>, up=<OpenGL.converters.CallFuncPyConverter object at 0x8ddffec>, startz=None, endz=None, twist=None
cConverters: ncp=<OpenGL.GLE.exceptional._lengthOfArgname object at 0x8e8484c>, contour=<OpenGL.converters.getPyArgsName object at 0x8d11e14>, cont_normal=<OpenGL.converters.getPyArgsName object at 0x8d11e64>, up=<OpenGL.converters.getPyArgsName object at 0x8d11eb4>, 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 0x8ddf3ac>, cont_normal=<OpenGL.converters.CallFuncPyConverter object at 0x8ddf8cc>, up=<OpenGL.converters.CallFuncPyConverter object at 0x8ddf0ec>, startRadius=None, drdTheta=None, startZ=None, dzdTheta=None, startXform=<OpenGL.converters.CallFuncPyConverter object at 0x8ddf78c>, dXformdTheta=<OpenGL.converters.CallFuncPyConverter object at 0x8ddff4c>, startTheta=None, sweepTheta=None
cConverters: ncp=<OpenGL.GLE.exceptional._lengthOfArgname object at 0x8e8404c>, contour=<OpenGL.converters.getPyArgsName object at 0x8d11f54>, cont_normal=<OpenGL.converters.getPyArgsName object at 0x8d11fa4>, up=<OpenGL.converters.getPyArgsName object at 0x8d1502c>, startRadius=None, drdTheta=None, startZ=None, dzdTheta=None, startXform=<OpenGL.converters.getPyArgsName object at 0x8d1507c>, dXformdTheta=<OpenGL.converters.getPyArgsName object at 0x8d150cc>, 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 0x8ddfaec>, cont_normal=<OpenGL.converters.CallFuncPyConverter object at 0x8ddf6ac>, up=<OpenGL.converters.CallFuncPyConverter object at 0x8ddf18c>, point_array=<OpenGL.converters.CallFuncPyConverter object at 0x8ddf96c>, color_array=<OpenGL.converters.CallFuncPyConverter object at 0x8ddf0ac>, xform_array=<OpenGL.converters.CallFuncPyConverter object at 0x8ddf24c>
cConverters: ncp=<OpenGL.GLE.exceptional._lengthOfArgname object at 0x8e84f4c>, contour=<OpenGL.converters.getPyArgsName object at 0x8d1516c>, cont_normal=<OpenGL.converters.getPyArgsName object at 0x8d151bc>, up=<OpenGL.converters.getPyArgsName object at 0x8d1520c>, npoints=<OpenGL.GLE.exceptional._lengthOfArgname object at 0x8e8440c>, point_array=<OpenGL.converters.getPyArgsName object at 0x8d1525c>, color_array=<OpenGL.converters.getPyArgsName object at 0x8d152ac>, xform_array=<OpenGL.converters.getPyArgsName object at 0x8d152fc>
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
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 at 0x8ddff0c>, dXformdTheta=<OpenGL.converters.CallFuncPyConverter object at 0x8ddf74c>, startTheta=None, sweepTheta=None
cConverters: rToroid=None, startRadius=None, drdTheta=None, startZ=None, dzdTheta=None, startXform=<OpenGL.converters.getPyArgsName object at 0x8d1539c>, dXformdTheta=<OpenGL.converters.getPyArgsName object at 0x8d153ec>, 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 at 0x8ddfb6c>, cont_normal=<OpenGL.converters.CallFuncPyConverter object at 0x8ddf04c>, up=<OpenGL.converters.CallFuncPyConverter object at 0x8ddfe8c>, point_array=<OpenGL.converters.CallFuncPyConverter object at 0x8ddfa0c>, color_array=<OpenGL.converters.CallFuncPyConverter object at 0x8ddfbac>, twist_array=<OpenGL.converters.CallFuncPyConverter object at 0x8ddf8ec>
cConverters: ncp=<OpenGL.GLE.exceptional._lengthOfArgname object at 0x8e84ecc>, contour=<OpenGL.converters.getPyArgsName object at 0x8d1548c>, cont_normal=<OpenGL.converters.getPyArgsName object at 0x8d154dc>, up=<OpenGL.converters.getPyArgsName object at 0x8d1552c>, npoints=<OpenGL.GLE.exceptional._lengthOfArgname object at 0x8e84fec>, point_array=<OpenGL.converters.getPyArgsName object at 0x8d1557c>, color_array=<OpenGL.converters.getPyArgsName object at 0x8d155cc>, twist_array=<OpenGL.converters.getPyArgsName object at 0x8d1561c>
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
memmove = <CFunctionType object at 0x8a3402c> memset = <CFunctionType object at 0x8a34094> - resize(...)
- Resize the memory buffer of a ctypes instance
rot_about_axis( angle,axis )
pyConverters: angle=None, axis=<OpenGL.converters.CallFuncPyConverter object at 0x8ddf2ac>
cConverters: angle=None, axis=<OpenGL.converters.getPyArgsName object at 0x8d156bc>
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 at 0x8ddfccc>
cConverters: omega=None, axis=<OpenGL.converters.getPyArgsName object at 0x8d1575c>
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 at 0x8ddf40c>
cConverters: axis=<OpenGL.converters.getPyArgsName object at 0x8d157fc>
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
- 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
urot_about_axis( m,angle,axis )
pyConverters: m=<OpenGL.converters.CallFuncPyConverter object at 0x8e84f6c>, angle=None, axis=<OpenGL.converters.CallFuncPyConverter object at 0x8e8468c>
cConverters: m=<OpenGL.converters.getPyArgsName object at 0x8d1589c>, angle=None, axis=<OpenGL.converters.getPyArgsName object at 0x8d158ec>
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 at 0x8e84eac>, omega=None, axis=<OpenGL.converters.CallFuncPyConverter object at 0x8e844cc>
cConverters: m=<OpenGL.converters.getPyArgsName object at 0x8d1598c>, omega=None, axis=<OpenGL.converters.getPyArgsName object at 0x8d159dc>
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 at 0x8e8474c>, axis=<OpenGL.converters.CallFuncPyConverter object at 0x8e8464c>
cConverters: m=<OpenGL.converters.getPyArgsName object at 0x8d15a7c>, axis=<OpenGL.converters.getPyArgsName object at 0x8d15acc>
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 at 0x8e848cc>, omega=None, axis=None
cConverters: m=<OpenGL.converters.getPyArgsName object at 0x8d15b6c>, 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 at 0x8e846ec>, v21=<OpenGL.converters.CallFuncPyConverter object at 0x8e84d2c>, up=<OpenGL.converters.CallFuncPyConverter object at 0x8e84b4c>
cConverters: m=<OpenGL.converters.getPyArgsName object at 0x8d15c0c>, v21=<OpenGL.converters.getPyArgsName object at 0x8d15c5c>, up=<OpenGL.converters.getPyArgsName object at 0x8d15cac>
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 at 0x8e8412c>, v1=<OpenGL.converters.CallFuncPyConverter object at 0x8e84e6c>, v2=<OpenGL.converters.CallFuncPyConverter object at 0x8e842ac>, up=<OpenGL.converters.CallFuncPyConverter object at 0x8e845ac>
cConverters: m=<OpenGL.converters.getPyArgsName object at 0x8d15d4c>, v1=<OpenGL.converters.getPyArgsName object at 0x8d15d9c>, v2=<OpenGL.converters.getPyArgsName object at 0x8d15dec>, up=<OpenGL.converters.getPyArgsName object at 0x8d15e3c>
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
|