| | """Base class for the various Python data-format storage type APIs |
| | |
| | Data-type handlers are specified using OpenGL.plugins module |
| | """ |
| | import ctypes |
| | from OpenGL import plugins |
| |
|
| | class FormatHandler( object ): |
| | """Abstract class describing the handler interface |
| | |
| | Each data-type handler is responsible for providing a number of methods |
| | which allow it to manipulate (and create) instances of the data-type |
| | it represents. |
| | """ |
| | LAZY_TYPE_REGISTRY = {} |
| | HANDLER_REGISTRY = {} |
| | baseType = None |
| | typeConstant = None |
| | HANDLED_TYPES = () |
| | preferredOutput = None |
| | isOutput = False |
| | GENERIC_OUTPUT_PREFERENCES = ['numpy','ctypesarrays'] |
| | ALL_OUTPUT_HANDLERS = [] |
| | def loadAll( cls ): |
| | """Load all OpenGL.plugins-registered FormatHandler classes |
| | """ |
| | for entrypoint in plugins.FormatHandler.all(): |
| | cls.loadPlugin( entrypoint ) |
| | @classmethod |
| | def loadPlugin( cls, entrypoint ): |
| | """Load a single entry-point via plugins module""" |
| | if not entrypoint.loaded: |
| | from OpenGL.arrays.arraydatatype import ArrayDatatype |
| | try: |
| | plugin_class = entrypoint.load() |
| | except ImportError as err: |
| | from OpenGL import logs |
| | from OpenGL._configflags import WARN_ON_FORMAT_UNAVAILABLE |
| | _log = logs.getLog( 'OpenGL.formathandler' ) |
| | if WARN_ON_FORMAT_UNAVAILABLE: |
| | logFunc = _log.warn |
| | else: |
| | logFunc = _log.info |
| | logFunc( |
| | 'Unable to load registered array format handler %s:\n%s', |
| | entrypoint.name, _log.getException( err ) |
| | ) |
| | else: |
| | handler = plugin_class() |
| | |
| | ArrayDatatype.getRegistry()[ entrypoint.name ] = handler |
| | return handler |
| | entrypoint.loaded = True |
| | @classmethod |
| | def typeLookup( cls, type ): |
| | """Lookup handler by data-type""" |
| | registry = ArrayDatatype.getRegistry() |
| | try: |
| | return registry[ type ] |
| | except KeyError as err: |
| | key = '%s.%s'%(type.__module__,type.__name__) |
| | plugin = cls.LAZY_TYPE_REGISTRY.get( key ) |
| | if plugin: |
| | cls.loadPlugin( plugin ) |
| | return registry[ type ] |
| | raise KeyError( """Unable to find data-format handler for %s"""%( type,)) |
| | loadAll = classmethod( loadAll ) |
| |
|
| | def register( self, types=None ): |
| | """Register this class as handler for given set of types""" |
| | from OpenGL.arrays.arraydatatype import ArrayDatatype |
| | ArrayDatatype.getRegistry().register( self, types ) |
| | def registerReturn( self ): |
| | """Register this handler as the default return-type handler""" |
| | from OpenGL.arrays.arraydatatype import ArrayDatatype |
| | ArrayDatatype.getRegistry().registerReturn( self ) |
| |
|
| | def from_param( self, value, typeCode=None ): |
| | """Convert to a ctypes pointer value""" |
| | def dataPointer( self, value ): |
| | """return long for pointer value""" |
| | def asArray( self, value, typeCode=None ): |
| | """Given a value, convert to array representation""" |
| | def arrayToGLType( self, value ): |
| | """Given a value, guess OpenGL type of the corresponding pointer""" |
| | def arraySize( self, value, typeCode = None ): |
| | """Given a data-value, calculate dimensions for the array""" |
| | def unitSize( self, value, typeCode=None ): |
| | """Determine unit size of an array (if possible)""" |
| | if self.baseType is not None: |
| | return |
| | def dimensions( self, value, typeCode=None ): |
| | """Determine dimensions of the passed array value (if possible)""" |
| |
|
