|
|
"""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', |
|
|
) |
|
|
|
