| """Implementations for common converter types""" |
| import ctypes,logging |
| from OpenGL._bytes import bytes, unicode, as_8_bit |
| from OpenGL._null import NULL |
| _log = logging.getLogger( 'OpenGL.converters' ) |
|
|
| class Converter( object ): |
| """Base class for Converter types |
| |
| Converter objects are callable objects used with the |
| OpenGL.wrapper.Wrapper class to simplify the wrapping |
| of functions by collecting commonly used functionality |
| into a reusable function. |
| |
| Each Converter has two (class) attributes: |
| |
| argNames -- list of argument names for initialisation |
| indexLookups -- set of (indexname, argName,methodName) values |
| to lookup on wrapper. These allow us to use argument-name |
| references to refer to which arguments to use when |
| processing (prevents the need to revise pointers when |
| we change the API for a function). |
| |
| Converters can be any of the Wrapper API helper functions, |
| so the callable interface can vary among Converter classes. |
| """ |
| argNames = ( ) |
| indexLookups = ( ) |
| def __init__( self, *args, **named ): |
| """Store arguments in attributes |
| |
| *args -- mapped to self.argNames in order to set attributes |
| **named -- mapped to self.argNames by name to set attributes |
| """ |
| argNames = list(self.argNames) |
| for a in self.argNames: |
| if a in named: |
| setattr( self, a, named[a] ) |
| argNames.remove( a ) |
| for a,value in zip( argNames, args ): |
| setattr( self, a, value ) |
| def finalise( self, wrapper ): |
| """Look up our indices (where appropriate)""" |
| for indexname,argName,methodName in self.indexLookups: |
| setattr( |
| self, indexname, |
| getattr(wrapper,methodName)(getattr( self, argName )) |
| ) |
|
|
| |
| class PyConverter( Converter ): |
| """Converter sub-class for use in Wrapper.pyConverters |
| |
| This class just defines the interface for a pyConverter-style |
| Converter object |
| """ |
| def __call__( self, incoming, function, arguments ): |
| """Convert incoming argument into compatable data-types |
| |
| incoming -- the Python argument for this parameter |
| function -- the wrapper.Wrapper class we are supporting |
| arguments -- the complete set of arguments passed to the |
| function |
| |
| |
| """ |
| raise NotImplemented( """%s class doesn't implement __call__"""%( |
| self.__class__.__name__, |
| )) |
|
|
| class CConverter( Converter ): |
| """Converter sub-class for use in Wrapper.cConverters |
| |
| This class just defines the interface for a cConverter-style |
| Converter object |
| """ |
| def __call__( self, pyArgs, index, baseOperation ): |
| """Calculate C-compatible Python object from Python arguments |
| |
| pyArgs -- set of Python argument objects converted by |
| pyConverters from the incoming arguments |
| index -- our index in baseOperation.cConverters |
| baseOperation -- the Wrapper object which we are supporting |
| """ |
| raise NotImplemented( """%s class doesn't implement __call__"""%( |
| self.__class__.__name__, |
| )) |
| class ReturnValues( Converter ): |
| """Converter sub-class for use as Wrapper.returnValues |
| |
| This class just defines the interface for a returnValues-style |
| Converter object |
| """ |
| def __call__( self, result, baseOperation, pyArgs, cArgs ): |
| """Return a final value to the caller |
| |
| result -- the raw ctypes result value |
| baseOperation -- the Wrapper object which we are supporting |
| pyArgs -- the set of Python arguments produced by pyConverters |
| cArgs -- the set of C-compatible arguments produced by CConverter |
| |
| return the Python object for the final result |
| """ |
| raise NotImplemented( """%s class doesn't implement __call__"""%( |
| self.__class__.__name__, |
| )) |
|
|
| |
| from OpenGL import acceleratesupport |
| CallFuncPyConverter = None |
| if acceleratesupport.ACCELERATE_AVAILABLE: |
| try: |
| from OpenGL_accelerate.wrapper import ( |
| CallFuncPyConverter, DefaultCConverter, getPyArgsName, |
| ) |
| from OpenGL_accelerate.arraydatatype import ( |
| Output,SizedOutput,OutputOrInput,SizedOutputOrInput |
| ) |
| from OpenGL_accelerate.wrapper import ( |
| returnCArgument, returnPyArgument, |
| ) |
| except ImportError as err: |
| _log.warn( |
| "Unable to load converters accelerators (wrapper, arraydatatype) from OpenGL_accelerate" |
| ) |
| CallFuncPyConverter = None |
| if CallFuncPyConverter is None: |
| class CallFuncPyConverter( PyConverter ): |
| """PyConverter that takes a callable and calls it on incoming""" |
| def __init__( self, function ): |
| """Store the function""" |
| self.function = function |
| def __call__( self, incoming, function, argument ): |
| """Call our function on incoming""" |
| return self.function( incoming ) |
| class DefaultCConverter( CConverter ): |
| """NULL or Default CConverter, returns same-named Python argument |
| |
| Used primarily to allow for specifying a converter that explicitly |
| says "use the default behaviour". This is *not* a finalise-ing |
| converter, it is passed in the index explicitly and just retrieves |
| that index from pyArgs when called. |
| |
| Raises informative errors if the index cannot be resolved in pyArgs |
| """ |
| def __init__( self, index ): |
| """Just store index for future access""" |
| self.index = index |
| def __call__( self, pyArgs, index, wrapper ): |
| """Return pyArgs[self.index] or raise a ValueError""" |
| try: |
| return pyArgs[ self.index ] |
| except IndexError as err: |
| raise ValueError( |
| """Expected parameter index %r, but pyArgs only length %s"""%( |
| self.index, |
| len(pyArgs ) |
| )) |
| class getPyArgsName( CConverter ): |
| """CConverter returning named Python argument |
| |
| Intended for use in cConverters, the function returned |
| retrieves the named pyArg and returns it when called. |
| """ |
| argNames = ('name',) |
| indexLookups = [ ('index','name', 'pyArgIndex' ), ] |
| __slots__ = ( 'index', 'name') |
| def __call__( self, pyArgs, index, baseOperation ): |
| """Return pyArgs[ self.index ]""" |
| try: |
| return pyArgs[ self.index ] |
| except AttributeError as err: |
| raise RuntimeError( """"Did not resolve parameter index for %r"""%(self.name)) |
|
|
| class Output( CConverter ): |
| """CConverter generating static-size typed output arrays |
| |
| Produces an output array of given type (arrayType) and |
| size using self.lookup() to determine the size of the |
| array to be produced, where the lookup function is passed |
| as an initialisation argument. |
| |
| Provides also: |
| |
| oldStyleReturn( ... ) for use in the default case of |
| PyOpenGL compatability mode, where result arrays of |
| size (1,) are returned as scalar values. |
| """ |
| argNames = ('name','size','arrayType' ) |
| indexLookups = [ |
| ('outIndex','name', 'cArgIndex' ), |
| ] |
| __slots__ = ('index','size','arrayType','outIndex','inIndex') |
| def __call__( self, pyArgs, index, baseOperation ): |
| """Return pyArgs[ self.index ]""" |
| return self.arrayType.zeros( self.getSize(pyArgs) ) |
| def getSize( self, pyArgs ): |
| """Retrieve the array size for this argument""" |
| return self.size |
| def oldStyleReturn( self, result, baseOperation, pyArgs, cArgs ): |
| """Retrieve cArgs[ self.index ]""" |
| result = cArgs[ self.outIndex ] |
| try: |
| thisSize = self.getSize(pyArgs) |
| except KeyError as err: |
| return result |
| if thisSize == (1,): |
| try: |
| return result[0] |
| except TypeError as err: |
| return result |
| else: |
| return result |
| class OutputOrInput( Output ): |
| DO_OUTPUT = (None,NULL) |
| def __call__( self, pyArgs, index, baseOperation ): |
| for do_output in self.DO_OUTPUT: |
| if pyArgs[index] is do_output: |
| return super( OutputOrInput,self ).__call__( pyArgs, index, baseOperation ) |
| return self.arrayType.asArray( pyArgs[index] ) |
|
|
| class SizedOutput( Output ): |
| """Output generating dynamically-sized typed output arrays |
| |
| Takes an extra parameter "specifier", which is the name of |
| a Python argument to be passed to the lookup function in order |
| to determine the appropriate size for the output array. |
| """ |
| argNames = ('name','specifier','lookup','arrayType' ) |
| indexLookups = [ |
| ('outIndex','name', 'cArgIndex' ), |
| ('index','specifier', 'pyArgIndex' ), |
| ] |
| __slots__ = ('index','specifier','lookup','arrayType') |
| def getSize( self, pyArgs ): |
| """Retrieve the array size for this argument""" |
| try: |
| specifier = pyArgs[ self.index ] |
| except AttributeError as err: |
| raise RuntimeError( """"Did not resolve parameter index for %r"""%(self.name)) |
| else: |
| try: |
| return self.lookup( specifier ) |
| except KeyError as err: |
| raise KeyError( """Unknown specifier %s"""%( specifier )) |
| class SizedOutputOrInput( SizedOutput ): |
| DO_OUTPUT = (None,NULL) |
| def __call__( self, pyArgs, index, baseOperation ): |
| for do_output in self.DO_OUTPUT: |
| if pyArgs[index] is do_output: |
| return super( SizedOutputOrInput,self ).__call__( pyArgs, index, baseOperation ) |
| return self.arrayType.asArray( pyArgs[index] ) |
| class returnCArgument( ReturnValues ): |
| """ReturnValues returning the named cArgs value""" |
| argNames = ('name',) |
| indexLookups = [ ('index','name', 'cArgIndex' ), ] |
| __slots__ = ( 'index', 'name' ) |
| def __call__( self, result, baseOperation, pyArgs, cArgs ): |
| """Retrieve cArgs[ self.index ]""" |
| return cArgs[self.index] |
|
|
| class returnPyArgument( ReturnValues ): |
| """ReturnValues returning the named pyArgs value""" |
| argNames = ('name',) |
| indexLookups = [ ('index','name', 'pyArgIndex' ), ] |
| __slots__ = ( 'index', 'name' ) |
| def __call__( self, result, baseOperation, pyArgs, cArgs ): |
| """Retrieve pyArgs[ self.index ]""" |
| return pyArgs[self.index] |
|
|
| class StringLengths( CConverter ): |
| """CConverter for processing array-of-pointers-to-strings data-type |
| |
| Converter is a CConverter for the array-of-lengths for a |
| array-of-pointers-to-strings data-type used to pass a set |
| of code fragments to the GLSL compiler. |
| |
| Provides also: |
| |
| stringArray -- PyConverter callable ensuring list-of-strings |
| format for the python argument |
| |
| stringArrayForC -- CResolver converting the array to |
| POINTER(c_char_p) format for passing to C |
| |
| totalCount -- CConverter callable giving count of string |
| pointers (that is, length of the pointer array) |
| """ |
| argNames = ('name',) |
| indexLookups = [ ('index','name', 'pyArgIndex' ), ] |
| __slots__ = () |
| def __call__( self, pyArgs, index, baseOperation ): |
| """Get array of length integers for string contents""" |
| from OpenGL.raw.GL import _types |
| tmp = [len(x) for x in pyArgs[self.index]] |
| a_type = _types.GLint * len(tmp) |
| return a_type( *tmp ) |
| def totalCount( self, pyArgs, index, baseOperation ): |
| """Get array of length integers for string contents""" |
| return len(pyArgs[self.index]) |
| def stringArray( self, arg, baseOperation, args ): |
| """Create basic array-of-strings object from pyArg""" |
| if isinstance( arg, (bytes,unicode) ): |
| arg = [arg] |
| value = [as_8_bit(x) for x in arg] |
| return value |
| def stringArrayForC( self, strings ): |
| """Create a ctypes pointer to char-pointer set""" |
| from OpenGL import arrays |
| result = (ctypes.c_char_p * len(strings))() |
| for i,s in enumerate(strings): |
| result[i] = ctypes.cast( |
| arrays.GLcharARBArray.dataPointer(s), |
| ctypes.c_char_p, |
| ) |
| return result |
|
|
