1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
|
"""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 = {} # more registrations
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()
# handler.register( handler.HANDLED_TYPES )
ArrayDatatype.getRegistry()[entrypoint.name] = handler
return handler
entrypoint.loaded = True
@classmethod
def typeLookup(cls, type):
"""Lookup handler by data-type"""
from OpenGL.arrays.arraydatatype import ArrayDatatype
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)"""
|
