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