| """Numbers passed as array handling code for PyOpenGL |
| """ |
| REGISTRY_NAME = 'numbers' |
| from OpenGL.raw.GL import _types |
| from OpenGL.raw.GL.VERSION import GL_1_1 |
| from OpenGL.arrays import formathandler |
| import ctypes |
| from OpenGL._bytes import long, integer_types |
|
|
| class NumberHandler( formathandler.FormatHandler ): |
| """Allows the user to pass a bald Python float,int, etceteras as an array-of-1""" |
| HANDLED_TYPES = integer_types + ( |
| float, |
| _types.GLdouble, |
| _types.GLfloat, |
| _types.GLint, |
| _types.GLshort, |
| _types.GLuint, |
| _types.GLulong, |
| _types.GLushort, |
| _types.GLclampf, |
| _types.GLclampd, |
| ) |
| def from_param( self, value, typeCode=None ): |
| """If it's a ctypes value, pass on, otherwise do asArray""" |
| try: |
| return ctypes.byref(value) |
| except TypeError as err: |
| err.args += (' If you have ERROR_ON_COPY enabled, remember to pass in an array to array-requiring functions.', ) |
| raise |
| dataPointer = from_param |
| def zeros( self, dims, typeCode=None ): |
| """Currently don't allow Number as output types!""" |
| raise NotImplemented( """Number data-type not allowed as an output array format""" ) |
| def ones( self, dims, typeCode=None ): |
| """Currently don't allow Number as output types!""" |
| raise NotImplemented( """Number data-type not allowed as an output array format""" ) |
| def arrayToGLType( self, value ): |
| """Given a value, guess OpenGL type of the corresponding pointer""" |
| if value.__class__ in TARGET_TYPES: |
| return TARGET_TYPES[ value.__class__ ] |
| else: |
| guess = DEFAULT_TYPES.get( value.__class__ ) |
| if guess is not None: |
| return guess[1] |
| raise TypeError( """Can't guess array data-type for %r types"""%(type(value))) |
| def arraySize( self, value, typeCode = None ): |
| """Given a data-value, calculate ravelled size for the array""" |
| return 1 |
| def asArray( self, value, typeCode=None ): |
| """Convert given value to an array value of given typeCode""" |
|
|
| if value.__class__ in TARGET_TYPES: |
| return value |
| targetType = CONSTANT_TO_TYPE.get( typeCode ) |
| if targetType is not None: |
| return targetType( value ) |
| raise TypeError( """Don't know how to convert %r to an array type"""%( |
| typeCode, |
| )) |
| def unitSize( self, value, typeCode=None ): |
| """Determine unit size of an array (if possible)""" |
| return 1 |
| def registerEquivalent( self, typ, base ): |
| """Register a sub-class for handling as the base-type""" |
| global TARGET_TYPE_TUPLE |
| for source in (DEFAULT_TYPES, TARGET_TYPES, BYTE_SIZES): |
| if base in source: |
| source[typ] = source[base] |
| if base in TARGET_TYPES: |
| TARGET_TYPE_TUPLE = TARGET_TYPE_TUPLE + (base,) |
|
|
| DEFAULT_TYPES = { |
| float: (_types.GLdouble,GL_1_1.GL_DOUBLE), |
| int: (_types.GLint,GL_1_1.GL_INT), |
| long: (_types.GLint,GL_1_1.GL_INT), |
| } |
| TARGET_TYPES = dict([ |
| (getattr( _types,n),c) |
| for (n,c) in _types.ARRAY_TYPE_TO_CONSTANT |
| ]) |
| TARGET_TYPE_TUPLE = tuple([ |
| getattr(_types,n) |
| for (n,c) in _types.ARRAY_TYPE_TO_CONSTANT |
| ]) |
| CONSTANT_TO_TYPE = dict([ |
| (c,getattr( _types, n)) |
| for (n,c) in _types.ARRAY_TYPE_TO_CONSTANT |
| ]) |
|
|
| BYTE_SIZES = dict([ |
| ( c, ctypes.sizeof( getattr( _types, n) ) ) |
| for (n,c) in _types.ARRAY_TYPE_TO_CONSTANT |
| ]) |
|
|
| try: |
| del n,c |
| except NameError as err: |
| pass |
|
|
