|
|
"""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 |
|
|
|
