| """Wrapper/Implementation of the GLU tessellator objects for PyOpenGL""" |
| from OpenGL.raw import GLU as _simple |
| from OpenGL.raw.GL.VERSION import GL_1_1 |
| from OpenGL.platform import createBaseFunction |
| from OpenGL.GLU import glustruct |
| from OpenGL import arrays, wrapper |
| from OpenGL.platform import PLATFORM |
| GLU = PLATFORM.GLU |
| from OpenGL.lazywrapper import lazy as _lazy |
| import ctypes |
|
|
| class GLUtesselator( glustruct.GLUStruct, _simple.GLUtesselator): |
| """Implementation class for GLUTessellator structures in OpenGL-ctypes""" |
| FUNCTION_TYPE = PLATFORM.functionTypeFor(PLATFORM.GLU) |
| CALLBACK_TYPES = { |
| |
| _simple.GLU_TESS_BEGIN: FUNCTION_TYPE( None, _simple.GLenum ), |
| _simple.GLU_TESS_BEGIN_DATA: FUNCTION_TYPE( |
| None, _simple.GLenum, ctypes.c_void_p |
| ), |
| _simple.GLU_TESS_EDGE_FLAG: FUNCTION_TYPE( None, _simple.GLboolean), |
| _simple.GLU_TESS_EDGE_FLAG_DATA: FUNCTION_TYPE( |
| None, _simple.GLboolean, ctypes.c_void_p |
| ), |
| _simple.GLU_TESS_VERTEX: FUNCTION_TYPE( None, ctypes.c_void_p ), |
| _simple.GLU_TESS_VERTEX_DATA: FUNCTION_TYPE( |
| None, ctypes.c_void_p, ctypes.c_void_p |
| ), |
| _simple.GLU_TESS_END: FUNCTION_TYPE( None ), |
| _simple.GLU_TESS_END_DATA: FUNCTION_TYPE( None, ctypes.c_void_p), |
| _simple.GLU_TESS_COMBINE: FUNCTION_TYPE( |
| None, |
| ctypes.POINTER(_simple.GLdouble), |
| ctypes.POINTER(ctypes.c_void_p), |
| ctypes.POINTER(_simple.GLfloat), |
| ctypes.POINTER(ctypes.c_void_p) |
| ), |
| _simple.GLU_TESS_COMBINE_DATA: FUNCTION_TYPE( |
| None, |
| ctypes.POINTER(_simple.GLdouble), |
| ctypes.POINTER(ctypes.c_void_p), |
| ctypes.POINTER(_simple.GLfloat), |
| ctypes.POINTER(ctypes.c_void_p), |
| ctypes.c_void_p, |
| ), |
| _simple.GLU_TESS_ERROR: FUNCTION_TYPE( None, _simple.GLenum), |
| _simple.GLU_TESS_ERROR_DATA: FUNCTION_TYPE( |
| None, _simple.GLenum, ctypes.c_void_p |
| ), |
| _simple.GLU_ERROR : FUNCTION_TYPE( None, _simple.GLenum ) |
| } |
| WRAPPER_METHODS = { |
| _simple.GLU_TESS_BEGIN_DATA: 'dataWrapper', |
| _simple.GLU_TESS_EDGE_FLAG_DATA: 'dataWrapper', |
| _simple.GLU_TESS_VERTEX: 'vertexWrapper', |
| _simple.GLU_TESS_VERTEX_DATA: 'vertexWrapper', |
| _simple.GLU_TESS_END_DATA: 'dataWrapper', |
| _simple.GLU_TESS_COMBINE: 'combineWrapper', |
| _simple.GLU_TESS_COMBINE_DATA: 'combineWrapper', |
| _simple.GLU_TESS_ERROR_DATA: 'dataWrapper', |
| } |
| def gluTessVertex( self, location, data=None ): |
| """Add a vertex to this tessellator, storing data for later lookup""" |
| vertexCache = getattr( self, 'vertexCache', None ) |
| if vertexCache is None: |
| self.vertexCache = [] |
| vertexCache = self.vertexCache |
| location = arrays.GLdoubleArray.asArray( location, GL_1_1.GL_DOUBLE ) |
| if arrays.GLdoubleArray.arraySize( location ) != 3: |
| raise ValueError( """Require 3 doubles for array location, got: %s"""%(location,)) |
| oorValue = self.noteObject(data) |
| vp = ctypes.c_void_p( oorValue ) |
| self.vertexCache.append( location ) |
| return gluTessVertexBase( self, location, vp ) |
| def gluTessBeginPolygon( self, data ): |
| """Note the object pointer to return it as a Python object""" |
| return _simple.gluTessBeginPolygon( |
| self, ctypes.c_void_p(self.noteObject( data )) |
| ) |
| def 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 |
| ) |
| """ |
| if (function is not None) and (not hasattr( function,'__call__' )): |
| raise TypeError( """Require a callable callback, got: %s"""%(function,)) |
| def wrap( coords, vertex_data, weight, outData, *args ): |
| """The run-time wrapper around the function""" |
| coords = self.ptrAsArray( coords, 3, arrays.GLdoubleArray ) |
| weight = self.ptrAsArray( weight, 4, arrays.GLfloatArray ) |
| |
| vertex_data = [ self.originalObject( vertex_data[i] ) for i in range(4) ] |
| args = tuple( [ self.originalObject( x ) for x in args ] ) |
| try: |
| result = function( coords, vertex_data, weight, *args ) |
| except Exception as err: |
| raise err.__class__( |
| """Failure during combine callback %r with args( %s,%s,%s,*%s):\n%s"""%( |
| function, coords, vertex_data, weight, args, str(err), |
| ) |
| ) |
| outP = ctypes.c_void_p(self.noteObject(result)) |
| if outData: |
| outData[0] = outP |
| else: |
| raise RuntimeError( "Null outData passed to callback" ) |
| return None |
| return wrap |
| def dataWrapper( self, function ): |
| """Wrap a function which only has the one data-pointer as last arg""" |
| if (function is not None) and (not hasattr( function,'__call__' )): |
| raise TypeError( """Require a callable callback, got: %s"""%(function,)) |
| def wrap( *args ): |
| """Just return the original object for polygon_data""" |
| args = args[:-1] + ( self.originalObject(args[-1]), ) |
| try: |
| return function( *args ) |
| except Exception as err: |
| err.args += (function,args) |
| raise |
| return wrap |
| def dataWrapper2( self, function ): |
| """Wrap a function which has two data-pointers as last args""" |
| if (function is not None) and (not hasattr( function,'__call__' )): |
| raise TypeError( """Require a callable callback, got: %s"""%(function,)) |
| def wrap( *args ): |
| """Just return the original object for polygon_data""" |
| args = args[:-2] + ( self.originalObject(args[-2]), self.originalObject(args[-1]), ) |
| try: |
| return function( *args ) |
| except Exception as err: |
| err.args += (function,args) |
| raise |
| return wrap |
| def vertexWrapper( self, function ): |
| """Converts a vertex-pointer into an OOR vertex for processing""" |
| if (function is not None) and (not hasattr( function,'__call__' )): |
| raise TypeError( """Require a callable callback, got: %s"""%(function,)) |
| def wrap( vertex, data=None ): |
| """Just return the original object for polygon_data""" |
| vertex = self.originalObject(vertex) |
| try: |
| if data is not None: |
| data = self.originalObject(data) |
| return function( vertex, data ) |
| else: |
| return function( vertex ) |
| except Exception as err: |
| err.args += (function,(vertex,data)) |
| raise |
| return wrap |
|
|
| GLUtesselator.CALLBACK_FUNCTION_REGISTRARS = dict([ |
| (c,createBaseFunction( |
| 'gluTessCallback', dll=GLU, resultType=None, |
| argTypes=[ctypes.POINTER(GLUtesselator), _simple.GLenum,funcType], |
| doc='gluTessCallback( POINTER(GLUtesselator)(tess), GLenum(which), _GLUfuncptr(CallBackFunc) ) -> None', |
| argNames=('tess', 'which', 'CallBackFunc'), |
| )) |
| for (c,funcType) in GLUtesselator.CALLBACK_TYPES.items() |
| ]) |
| try: |
| del c, funcType |
| except NameError as err: |
| pass |
|
|
| def gluTessCallback( tess, which, function ): |
| """Set a given gluTessellator callback for the given tessellator""" |
| return tess.addCallback( which, function ) |
| def gluTessBeginPolygon( tess, data ): |
| """Start definition of polygon in the tessellator""" |
| return tess.gluTessBeginPolygon( data ) |
| def gluTessVertex( tess, location, data=None ): |
| """Add a vertex to the tessellator's current polygon""" |
| return tess.gluTessVertex( location, data ) |
|
|
| |
| @_lazy( |
| createBaseFunction( |
| 'gluNewTess', dll=GLU, resultType=ctypes.POINTER(GLUtesselator), |
| doc='gluNewTess( ) -> POINTER(GLUtesselator)', |
| ) |
| ) |
| def gluNewTess( baseFunction ): |
| """Get a new tessellator object (just unpacks the pointer for you)""" |
| return baseFunction()[0] |
|
|
| @_lazy( _simple.gluGetTessProperty ) |
| def gluGetTessProperty( baseFunction, tess, which, data=None ): |
| """Retrieve single double for a tessellator property""" |
| if data is None: |
| data = _simple.GLdouble( 0.0 ) |
| baseFunction( tess, which, data ) |
| return data.value |
| else: |
| return baseFunction( tess, which, data ) |
|
|
| gluTessVertexBase = wrapper.wrapper( _simple.gluTessVertex ).setInputArraySize( |
| 'location', |
| 3, |
| ) |
|
|
| __all__ = ( |
| 'gluNewTess', |
| 'gluGetTessProperty', |
| 'gluTessBeginPolygon', |
| 'gluTessCallback', |
| 'gluTessVertex', |
| ) |
|
|
