| |
- 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 0x87a1f0c>, cont_normal=<OpenGL.converters.CallFuncPyConverter object at 0x87a11ec>, up=<OpenGL.converters.CallFuncPyConverter object at 0x87a130c>, point_array=<OpenGL.converters.CallFuncPyConverter object at 0x87a138c>, color_array=<OpenGL.converters.CallFuncPyConverter object at 0x87a1f6c>
cConverters: ncp=<OpenGL.GLE.exceptional._lengthOfArgname object at 0x879610c>, contour=<OpenGL.converters.getPyArgsName object at 0x854539c>, cont_normal=<OpenGL.converters.getPyArgsName object at 0x85453ec>, up=<OpenGL.converters.getPyArgsName object at 0x854543c>, npoints=<OpenGL.GLE.exceptional._lengthOfArgname object at 0x87964ac>, point_array=<OpenGL.converters.getPyArgsName object at 0x854548c>, color_array=<OpenGL.converters.getPyArgsName object at 0x85454dc>
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 0x87a1a4c>, dXformdTheta=<OpenGL.converters.CallFuncPyConverter object at 0x87a152c>, startTheta=None, sweepTheta=None
cConverters: rToroid=None, startRadius=None, drdTheta=None, startZ=None, dzdTheta=None, startXform=<OpenGL.converters.getPyArgsName object at 0x8545554>, dXformdTheta=<OpenGL.converters.getPyArgsName object at 0x85455a4>, 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 0x874c14c>, cont_normal=<OpenGL.converters.CallFuncPyConverter object at 0x874ce4c>, up=<OpenGL.converters.CallFuncPyConverter object at 0x874cdec>, startRadius=None, drdTheta=None, startZ=None, dzdTheta=None, startXform=<OpenGL.converters.CallFuncPyConverter object at 0x874c2cc>, dXformdTheta=<OpenGL.converters.CallFuncPyConverter object at 0x874cf8c>, startTheta=None, sweepTheta=None
cConverters: ncp=<OpenGL.GLE.exceptional._lengthOfArgname object at 0x8796fcc>, contour=<OpenGL.converters.getPyArgsName object at 0x854561c>, cont_normal=<OpenGL.converters.getPyArgsName object at 0x854566c>, up=<OpenGL.converters.getPyArgsName object at 0x85456bc>, startRadius=None, drdTheta=None, startZ=None, dzdTheta=None, startXform=<OpenGL.converters.getPyArgsName object at 0x854570c>, dXformdTheta=<OpenGL.converters.getPyArgsName object at 0x854575c>, 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 0x874c90c>, color_array=<OpenGL.converters.CallFuncPyConverter object at 0x874cfec>, radius_array=<OpenGL.converters.CallFuncPyConverter object at 0x874ca6c>
cConverters: npoints=<OpenGL.GLE.exceptional._lengthOfArgname object at 0x8796f2c>, point_array=<OpenGL.converters.getPyArgsName object at 0x85457d4>, color_array=<OpenGL.converters.getPyArgsName object at 0x8545824>, radius_array=<OpenGL.converters.getPyArgsName object at 0x8545874>
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 0x874c7ec>, color_array=<OpenGL.converters.CallFuncPyConverter object at 0x874c74c>, radius=None
cConverters: npoints=<OpenGL.GLE.exceptional._lengthOfArgname object at 0x879608c>, point_array=<OpenGL.converters.getPyArgsName object at 0x85458ec>, color_array=<OpenGL.converters.getPyArgsName object at 0x854593c>, 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 0x874cbac>, cont_normal=<OpenGL.converters.CallFuncPyConverter object at 0x874caec>, up=<OpenGL.converters.CallFuncPyConverter object at 0x874c6cc>, startz=None, endz=None, twist=None
cConverters: ncp=<OpenGL.GLE.exceptional._lengthOfArgname object at 0x8796f0c>, contour=<OpenGL.converters.getPyArgsName object at 0x85459dc>, cont_normal=<OpenGL.converters.getPyArgsName object at 0x8545a2c>, up=<OpenGL.converters.getPyArgsName object at 0x8545a7c>, 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 0x874ce0c>, cont_normal=<OpenGL.converters.CallFuncPyConverter object at 0x874cc6c>, up=<OpenGL.converters.CallFuncPyConverter object at 0x874c28c>, startRadius=None, drdTheta=None, startZ=None, dzdTheta=None, startXform=<OpenGL.converters.CallFuncPyConverter object at 0x874c8ac>, dXformdTheta=<OpenGL.converters.CallFuncPyConverter object at 0x874ca4c>, startTheta=None, sweepTheta=None
cConverters: ncp=<OpenGL.GLE.exceptional._lengthOfArgname object at 0x879682c>, contour=<OpenGL.converters.getPyArgsName object at 0x8545b1c>, cont_normal=<OpenGL.converters.getPyArgsName object at 0x8545b6c>, up=<OpenGL.converters.getPyArgsName object at 0x8545bbc>, startRadius=None, drdTheta=None, startZ=None, dzdTheta=None, startXform=<OpenGL.converters.getPyArgsName object at 0x8545c0c>, dXformdTheta=<OpenGL.converters.getPyArgsName object at 0x8545c5c>, 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 0x874c20c>, cont_normal=<OpenGL.converters.CallFuncPyConverter object at 0x874c8ec>, up=<OpenGL.converters.CallFuncPyConverter object at 0x874c36c>, point_array=<OpenGL.converters.CallFuncPyConverter object at 0x87a8a4c>, color_array=<OpenGL.converters.CallFuncPyConverter object at 0x87a896c>, xform_array=<OpenGL.converters.CallFuncPyConverter object at 0x87a850c>
cConverters: ncp=<OpenGL.GLE.exceptional._lengthOfArgname object at 0x8796b0c>, contour=<OpenGL.converters.getPyArgsName object at 0x8545cfc>, cont_normal=<OpenGL.converters.getPyArgsName object at 0x8545d4c>, up=<OpenGL.converters.getPyArgsName object at 0x8545d9c>, npoints=<OpenGL.GLE.exceptional._lengthOfArgname object at 0x879656c>, point_array=<OpenGL.converters.getPyArgsName object at 0x8545dec>, color_array=<OpenGL.converters.getPyArgsName object at 0x8545e3c>, xform_array=<OpenGL.converters.getPyArgsName object at 0x8545e8c>
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 0x87a86ec>, dXformdTheta=<OpenGL.converters.CallFuncPyConverter object at 0x87a8c0c>, startTheta=None, sweepTheta=None
cConverters: rToroid=None, startRadius=None, drdTheta=None, startZ=None, dzdTheta=None, startXform=<OpenGL.converters.getPyArgsName object at 0x8545f2c>, dXformdTheta=<OpenGL.converters.getPyArgsName object at 0x8545f7c>, 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 0x87a886c>, cont_normal=<OpenGL.converters.CallFuncPyConverter object at 0x87a894c>, up=<OpenGL.converters.CallFuncPyConverter object at 0x87a87cc>, point_array=<OpenGL.converters.CallFuncPyConverter object at 0x87a8f6c>, color_array=<OpenGL.converters.CallFuncPyConverter object at 0x87a86ac>, twist_array=<OpenGL.converters.CallFuncPyConverter object at 0x87a802c>
cConverters: ncp=<OpenGL.GLE.exceptional._lengthOfArgname object at 0x8796a6c>, contour=<OpenGL.converters.getPyArgsName object at 0x8548054>, cont_normal=<OpenGL.converters.getPyArgsName object at 0x85480a4>, up=<OpenGL.converters.getPyArgsName object at 0x85480f4>, npoints=<OpenGL.GLE.exceptional._lengthOfArgname object at 0x879690c>, point_array=<OpenGL.converters.getPyArgsName object at 0x8548144>, color_array=<OpenGL.converters.getPyArgsName object at 0x8548194>, twist_array=<OpenGL.converters.getPyArgsName object at 0x85481e4>
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 0x835602c> memset = <CFunctionType object at 0x8356094> - resize(...)
- Resize the memory buffer of a ctypes instance
rot_about_axis( angle,axis )
pyConverters: angle=None, axis=<OpenGL.converters.CallFuncPyConverter object at 0x87a88ac>
cConverters: angle=None, axis=<OpenGL.converters.getPyArgsName object at 0x8548284>
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 0x87a828c>
cConverters: omega=None, axis=<OpenGL.converters.getPyArgsName object at 0x8548324>
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 0x87a83ac>
cConverters: axis=<OpenGL.converters.getPyArgsName object at 0x85483c4>
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 0x87a852c>, angle=None, axis=<OpenGL.converters.CallFuncPyConverter object at 0x87a8d2c>
cConverters: m=<OpenGL.converters.getPyArgsName object at 0x8548464>, angle=None, axis=<OpenGL.converters.getPyArgsName object at 0x85484b4>
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 0x87a8fac>, omega=None, axis=<OpenGL.converters.CallFuncPyConverter object at 0x87a8f4c>
cConverters: m=<OpenGL.converters.getPyArgsName object at 0x8548554>, omega=None, axis=<OpenGL.converters.getPyArgsName object at 0x85485a4>
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 0x87a8d0c>, axis=<OpenGL.converters.CallFuncPyConverter object at 0x87a8bac>
cConverters: m=<OpenGL.converters.getPyArgsName object at 0x8548644>, axis=<OpenGL.converters.getPyArgsName object at 0x8548694>
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 0x87a848c>, omega=None, axis=None
cConverters: m=<OpenGL.converters.getPyArgsName object at 0x8548734>, 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 0x87a8e6c>, v21=<OpenGL.converters.CallFuncPyConverter object at 0x879668c>, up=<OpenGL.converters.CallFuncPyConverter object at 0x8796bec>
cConverters: m=<OpenGL.converters.getPyArgsName object at 0x85487d4>, v21=<OpenGL.converters.getPyArgsName object at 0x8548824>, up=<OpenGL.converters.getPyArgsName object at 0x8548874>
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 0x8796acc>, v1=<OpenGL.converters.CallFuncPyConverter object at 0x879634c>, v2=<OpenGL.converters.CallFuncPyConverter object at 0x87961ec>, up=<OpenGL.converters.CallFuncPyConverter object at 0x879614c>
cConverters: m=<OpenGL.converters.getPyArgsName object at 0x8548914>, v1=<OpenGL.converters.getPyArgsName object at 0x8548964>, v2=<OpenGL.converters.getPyArgsName object at 0x85489b4>, up=<OpenGL.converters.getPyArgsName object at 0x8548a04>
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
|