OpenGL.GLU.tess
index
/home/mcfletch/pylive/OpenGL/GLU/tess.py

Wrapper/Implementation of the GLU tessellator objects for PyOpenGL

 
Modules
       
OpenGL.arrays
OpenGL.constants
ctypes
OpenGL.GLU.glustruct
OpenGL.raw.GLU

 
Classes
       
GLUStruct(object)
GLUtesselator(GLUStruct, GLUtesselator)
GLUtesselator(Structure)
GLUtesselator(GLUStruct, GLUtesselator)

 
class GLUtesselator(GLUStruct, GLUtesselator)
    Implementation class for GLUTessellator structures in OpenGL-ctypes
 
 
Method resolution order:
GLUtesselator
GLUStruct
GLUtesselator
Structure
_ctypes._CData
object

Methods defined here:
FUNCTION_TYPE = CFUNCTYPE(restype, *argtypes, **kw)
CFUNCTYPE(restype, *argtypes,
             use_errno=False, use_last_error=False) -> function prototype.
 
restype: the result type
argtypes: a sequence specifying the argument types
 
The function prototype can be called in different ways to create a
callable object:
 
prototype(integer address) -> foreign function
prototype(callable) -> create and return a C callable function from callable
prototype(integer index, method name[, paramflags]) -> foreign function calling a COM method
prototype((ordinal number, dll object)[, paramflags]) -> foreign function exported by ordinal
prototype((function name, dll object)[, paramflags]) -> foreign function exported by name
combineWrapper(self, function)
Wrap a Python function with ctypes-compatible wrapper for combine callback
 
For a Python combine callback, the signature looks like this:
    def combine(
        GLdouble coords[3], 
        void *vertex_data[4], 
        GLfloat weight[4]
    ):
        return data
While the C signature looks like this:
    void combine( 
        GLdouble coords[3], 
        void *vertex_data[4], 
        GLfloat weight[4], 
        void **outData 
    )
dataWrapper(self, function)
Wrap a function which only has the one data-pointer as last arg
dataWrapper2(self, function)
Wrap a function which has two data-pointers as last args
gluTessBeginPolygon(self, data)
Note the object pointer to return it as a Python object
gluTessVertex(self, location, data=None)
Add a vertex to this tessellator, storing data for later lookup
vertexWrapper(self, function)
Converts a vertex-pointer into an OOR vertex for processing

Data and other attributes defined here:
CALLBACK_FUNCTION_REGISTRARS = {GLU_TESS_BEGIN: <CFunctionType object at 0x28f4d50>, GLU_TESS_VERTEX: <CFunctionType object at 0x28f4e20>, GLU_TESS_END: <CFunctionType object at 0x28f4ef0>, GLU_TESS_ERROR: <CFunctionType object at 0x2905050>, GLU_TESS_EDGE_FLAG: <CFunctionType object at 0x2905120>, GLU_TESS_COMBINE: <CFunctionType object at 0x29051f0>, GLU_TESS_BEGIN_DATA: <CFunctionType object at 0x29052c0>, GLU_TESS_VERTEX_DATA: <CFunctionType object at 0x2905390>, GLU_TESS_END_DATA: <CFunctionType object at 0x2905460>, GLU_TESS_ERROR_DATA: <CFunctionType object at 0x2905530>, ...}
CALLBACK_TYPES = {GLU_TESS_BEGIN: <class 'ctypes.CFunctionType'>, GLU_TESS_VERTEX: <class 'ctypes.CFunctionType'>, GLU_TESS_END: <class 'ctypes.CFunctionType'>, GLU_TESS_ERROR: <class 'ctypes.CFunctionType'>, GLU_TESS_EDGE_FLAG: <class 'ctypes.CFunctionType'>, GLU_TESS_COMBINE: <class 'ctypes.CFunctionType'>, GLU_TESS_BEGIN_DATA: <class 'ctypes.CFunctionType'>, GLU_TESS_VERTEX_DATA: <class 'ctypes.CFunctionType'>, GLU_TESS_END_DATA: <class 'ctypes.CFunctionType'>, GLU_TESS_ERROR_DATA: <class 'ctypes.CFunctionType'>, ...}
WRAPPER_METHODS = {GLU_TESS_VERTEX: 'vertexWrapper', GLU_TESS_COMBINE: 'combineWrapper', GLU_TESS_BEGIN_DATA: 'dataWrapper', GLU_TESS_VERTEX_DATA: 'vertexWrapper', GLU_TESS_END_DATA: 'dataWrapper', GLU_TESS_ERROR_DATA: 'dataWrapper', GLU_TESS_EDGE_FLAG_DATA: 'dataWrapper', GLU_TESS_COMBINE_DATA: 'combineWrapper'}

Methods inherited from GLUStruct:
addCallback(self, which, function)
Register a callback for this structure object
getAsParam(self)
Gets as a ctypes pointer to the underlying structure
noteObject(self, object)
Note object for later retrieval as a Python object pointer
 
This is the registration point for "original object return", returns 
a void pointer to the Python object, though this is, effectively, an 
opaque value.
originalObject(self, voidPointer)
Given a void-pointer, try to find our original Python object
ptrAsArray(self, ptr, length, type)
Copy length values from ptr into new array of given type

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

Methods inherited from Structure:
__init__(...)
x.__init__(...) initializes x; see x.__class__.__doc__ for signature

Data and other attributes inherited from Structure:
__new__ = <built-in method __new__ of _ctypes.StructType object at 0x7f8ebe8a9960>
T.__new__(S, ...) -> a new object with type S, a subtype of T

Methods inherited from _ctypes._CData:
__ctypes_from_outparam__(...)
__hash__(...)
x.__hash__() <==> hash(x)
__reduce__(...)
__setstate__(...)

 
Functions
       
gluTessBeginPolygon(tess, data)
Start definition of polygon in the tessellator
gluTessCallback(tess, which, function)
Set a given gluTessellator callback for the given tessellator
gluTessVertex(tess, location, data=None)
Add a vertex to the tessellator's current polygon

 
Data
        GLU = <CDLL 'libGLU.so.1', handle 2189a60 at 2156790>
PLATFORM = <OpenGL.platform.glx.GLXPlatform object at 0x20bad90>
__all__ = ('gluNewTess', 'gluGetTessProperty', 'gluTessBeginPolygon', 'gluTessCallback', 'gluTessVertex')
__file__ = '/home/mcfletch/pylive/OpenGL/GLU/tess.pyc'
__name__ = 'OpenGL.GLU.tess'
__package__ = 'OpenGL.GLU'
gluGetTessProperty = OpenGL.lazywrapper.lazy( 'gluGetTessProperty' )
gluNewTess = OpenGL.lazywrapper.lazy( 'gluNewTess' )
gluTessVertexBase = <OpenGL.wrapper.gluTessVertex object at 0x2907758>