arraydatatype.py :  » Game-2D-3D » PyOpenGL » PyOpenGL-3.0.1 » OpenGL » arrays » Python Open Source

Home
Python Open Source
1.3.1.2 Python
2.Ajax
3.Aspect Oriented
4.Blog
5.Build
6.Business Application
7.Chart Report
8.Content Management Systems
9.Cryptographic
10.Database
11.Development
12.Editor
13.Email
14.ERP
15.Game 2D 3D
16.GIS
17.GUI
18.IDE
19.Installer
20.IRC
21.Issue Tracker
22.Language Interface
23.Log
24.Math
25.Media Sound Audio
26.Mobile
27.Network
28.Parser
29.PDF
30.Project Management
31.RSS
32.Search
33.Security
34.Template Engines
35.Test
36.UML
37.USB Serial
38.Web Frameworks
39.Web Server
40.Web Services
41.Web Unit
42.Wiki
43.Windows
44.XML
Python Open Source » Game 2D 3D » PyOpenGL 
PyOpenGL » PyOpenGL 3.0.1 » OpenGL » arrays » arraydatatype.py
"""Array data-type implementations (abstraction points for GL array types"""
import ctypes
import OpenGL
from OpenGL import constants,plugins
from OpenGL.arrays import formathandler
from OpenGL import logs
log = logs.getLog( 'OpenGL.arrays.arraydatatype' )


from OpenGL import acceleratesupport
ADT = None
if acceleratesupport.ACCELERATE_AVAILABLE:
    try:
        from OpenGL_accelerate.arraydatatype import ArrayDatatype
    except ImportError, err:
        log.warn(
            "Unable to load ArrayDatatype accelerator from OpenGL_accelerate"
        )
if ADT is None:
    # Python-coded version
    class HandlerRegistry( dict ):
        GENERIC_OUTPUT_PREFERENCES = ['numpy','numeric','ctypesarrays']
        def __init__( self, plugin_match ):
            self.match = plugin_match
            self.output_handler = None 
            self.preferredOutput = None
            self.all_output_handlers = []
        def __call__( self, value ):
            """Lookup of handler for given value"""
            try:
                typ = value.__class__
            except AttributeError, err:
                typ = type(value)
            handler = self.get( typ )
            if not handler:
                if hasattr( typ, '__mro__' ):
                    for base in typ.__mro__:
                        handler = self.get( base )
                        if not handler:
                            handler = self.match( base )
                            if handler:
                                handler = handler.load()
                                if handler:
                                    handler = handler()
                        if handler:
                            self[ typ ] = handler
                            if hasattr( handler, 'registerEquivalent' ):
                                handler.registerEquivalent( typ, base )
                            return handler
                raise TypeError(
                    """No array-type handler for type %r (value: %s) registered"""%(
                        typ, repr(value)[:50]
                    )
                )
            return handler
        
        def get_output_handler( self ):
            """Fast-path lookup for output handler object"""
            if self.output_handler is None:
                if not self:
                    formathandler.FormatHandler.loadAll()
                if self.preferredOutput is not None:
                    self.output_handler = self.get( self.preferredOutput )
                if not self.output_handler:
                    for preferred in self.GENERIC_OUTPUT_PREFERENCES:
                        self.output_handler = self.get( preferred )
                        if self.output_handler:
                            break
                if not self.output_handler:
                    # look for anything that can do output...
                    for handler in self.all_output_handlers:
                        self.output_handler = handler 
                        break
                if not self.output_handler:
                    raise RuntimeError(
                        """Unable to find any output handler at all (not even ctypes/numpy ones!)"""
                    )
            return self.output_handler
        
        def register( self, handler, types=None ):
            """Register this class as handler for given set of types"""
            if not isinstance( types, (list,tuple)):
                types = [ types ]
            for type in types:
                self[ type ] = handler
            if handler.isOutput:
                self.all_output_handlers.append( handler )
            
        def registerReturn( self, handler ):
            """Register this handler as the default return-type handler"""
            self.preferredOutput = handler 
            self.output_handler = None
    
    GLOBAL_REGISTRY = HandlerRegistry( plugins.FormatHandler.match)
    formathandler.FormatHandler.TYPE_REGISTRY = GLOBAL_REGISTRY
    
    class ArrayDatatype( object ):
        """Mix-in for array datatype classes
        
        The ArrayDatatype marker essentially is used to mark a particular argument
        as having an "array" type, which means that it is eligible for handling 
        via the arrays sub-package and its registered handlers.
        """
        typeConstant = None
        handler = GLOBAL_REGISTRY
        getHandler = GLOBAL_REGISTRY.__call__
        returnHandler = GLOBAL_REGISTRY.get_output_handler
        isAccelerated = False
        @classmethod
        def getRegistry( cls ):
            """Get our handler registry"""
            return cls.handler 
        def from_param( cls, value ):
            """Given a value in a known data-pointer type, convert to a ctypes pointer"""
            return cls.getHandler(value).from_param( value, cls.typeConstant )
        from_param = classmethod( logs.logOnFail( from_param, log ) )
        def dataPointer( cls, value ):
            """Given a value in a known data-pointer type, return long for pointer"""
            try:
                return cls.getHandler(value).dataPointer( value )
            except Exception, err:
                log.warn(
                    """Failure in dataPointer for %s instance %s""", type(value), value,
                )
                raise
        dataPointer = classmethod( logs.logOnFail( dataPointer, log ) )
        def voidDataPointer( cls, value ):
            """Given value in a known data-pointer type, return void_p for pointer"""
            pointer = cls.dataPointer( value )
            try:
                return ctypes.c_void_p(pointer)
            except TypeError, err:
                return pointer
        voidDataPointer = classmethod( logs.logOnFail( voidDataPointer, log ) )
        def typedPointer( cls, value ):
            """Return a pointer-to-base-type pointer for given value"""
            return ctypes.cast( cls.dataPointer(value), ctypes.POINTER( cls.baseType ))
        typedPointer = classmethod( typedPointer )
        def asArray( cls, value, typeCode=None ):
            """Given a value, convert to preferred array representation"""
            return cls.getHandler(value).asArray( value, typeCode or cls.typeConstant )
        asArray = classmethod( logs.logOnFail( asArray, log ) )
        def arrayToGLType( cls, value ):
            """Given a data-value, guess the OpenGL type of the corresponding pointer
            
            Note: this is not currently used in PyOpenGL and may be removed 
            eventually.
            """
            return cls.getHandler(value).arrayToGLType( value )
        arrayToGLType = classmethod( logs.logOnFail( arrayToGLType, log ) )
        def arraySize( cls, value, typeCode = None ):
            """Given a data-value, calculate dimensions for the array (number-of-units)"""
            return cls.getHandler(value).arraySize( value, typeCode or cls.typeConstant )
        arraySize = classmethod( logs.logOnFail( arraySize, log ) )
        def unitSize( cls, value, typeCode=None ):
            """Determine unit size of an array (if possible)
            
            Uses our local type if defined, otherwise asks the handler to guess...
            """
            return cls.getHandler(value).unitSize( value, typeCode or cls.typeConstant )
        unitSize = classmethod( logs.logOnFail( unitSize, log ) )
        def zeros( cls, dims, typeCode=None ):
            """Allocate a return array of the given dimensions filled with zeros"""
            return cls.returnHandler().zeros( dims, typeCode or cls.typeConstant )
        zeros = classmethod( logs.logOnFail( zeros, log ) )
        def dimensions( cls, value ):
            """Given a data-value, get the dimensions (assumes full structure info)"""
            return cls.getHandler(value).dimensions( value )
        dimensions = classmethod( logs.logOnFail( dimensions, log ) )
        
        def arrayByteCount( cls, value ):
            """Given a data-value, try to determine number of bytes it's final form occupies
            
            For most data-types this is arraySize() * atomic-unit-size
            """
            return cls.getHandler(value).arrayByteCount( value )
        arrayByteCount = classmethod( logs.logOnFail( arrayByteCount, log ) )
            

    # the final array data-type classes...
    class GLclampdArray( ArrayDatatype, ctypes.POINTER(constants.GLclampd )):
        """Array datatype for GLclampd types"""
        baseType = constants.GLclampd
        typeConstant = constants.GL_DOUBLE

    class GLclampfArray( ArrayDatatype, ctypes.POINTER(constants.GLclampf )):
        """Array datatype for GLclampf types"""
        baseType = constants.GLclampf
        typeConstant = constants.GL_FLOAT

    class GLfloatArray( ArrayDatatype, ctypes.POINTER(constants.GLfloat )):
        """Array datatype for GLfloat types"""
        baseType = constants.GLfloat
        typeConstant = constants.GL_FLOAT

    class GLdoubleArray( ArrayDatatype, ctypes.POINTER(constants.GLdouble )):
        """Array datatype for GLdouble types"""
        baseType = constants.GLdouble
        typeConstant = constants.GL_DOUBLE

    class GLbyteArray( ArrayDatatype, ctypes.POINTER(constants.GLbyte )):
        """Array datatype for GLbyte types"""
        baseType = constants.GLbyte
        typeConstant = constants.GL_BYTE

    class GLcharArray( ArrayDatatype, ctypes.c_char_p):
        """Array datatype for ARB extension pointers-to-arrays"""
        baseType = constants.GLchar
        typeConstant = constants.GL_BYTE
    GLcharARBArray = GLcharArray

    class GLshortArray( ArrayDatatype, ctypes.POINTER(constants.GLshort )):
        """Array datatype for GLshort types"""
        baseType = constants.GLshort
        typeConstant = constants.GL_SHORT

    class GLintArray( ArrayDatatype, ctypes.POINTER(constants.GLint )):
        """Array datatype for GLint types"""
        baseType = constants.GLint
        typeConstant = constants.GL_INT

    class GLubyteArray( ArrayDatatype, ctypes.POINTER(constants.GLubyte )):
        """Array datatype for GLubyte types"""
        baseType = constants.GLubyte
        typeConstant = constants.GL_UNSIGNED_BYTE
    GLbooleanArray = GLubyteArray

    class GLushortArray( ArrayDatatype, ctypes.POINTER(constants.GLushort )):
        """Array datatype for GLushort types"""
        baseType = constants.GLushort
        typeConstant = constants.GL_UNSIGNED_SHORT

    class GLuintArray( ArrayDatatype, ctypes.POINTER(constants.GLuint )):
        """Array datatype for GLuint types"""
        baseType = constants.GLuint
        typeConstant = constants.GL_UNSIGNED_INT
    
    class GLint64Array( ArrayDatatype, ctypes.POINTER(constants.GLint64 )):
        """Array datatype for GLuint types"""
        baseType = constants.GLint64
        typeConstant = None # TODO: find out what this should be!
    
    class GLuint64Array( ArrayDatatype, ctypes.POINTER(constants.GLuint64 )):
        """Array datatype for GLuint types"""
        baseType = constants.GLuint64
        typeConstant = constants.GL_UNSIGNED_INT64

    class GLenumArray( ArrayDatatype, ctypes.POINTER(constants.GLenum )):
        """Array datatype for GLenum types"""
        baseType = constants.GLenum
        typeConstant = constants.GL_UNSIGNED_INT
    class GLsizeiArray( ArrayDatatype, ctypes.POINTER(constants.GLsizei )):
        """Array datatype for GLenum types"""
        baseType = constants.GLsizei
        typeConstant = constants.GL_INT
else:
    # Cython-coded array handler
    log.info( 'Using accelerated ArrayDatatype' )
    ArrayDatatype = ADT( None, None )
    GLclampdArray = ADT( constants.GL_DOUBLE, constants.GLclampd )
    GLclampfArray = ADT( constants.GL_FLOAT, constants.GLclampf )
    GLdoubleArray = ADT( constants.GL_DOUBLE, constants.GLdouble )
    GLfloatArray = ADT( constants.GL_FLOAT, constants.GLfloat )
    GLbyteArray = ADT( constants.GL_BYTE, constants.GLbyte )
    GLcharArray = GLcharARBArray = ADT( constants.GL_BYTE, constants.GLchar )
    GLshortArray = ADT( constants.GL_SHORT, constants.GLshort )
    GLintArray = ADT( constants.GL_INT, constants.GLint )
    GLubyteArray = GLbooleanArray = ADT( constants.GL_UNSIGNED_BYTE, constants.GLubyte )
    GLushortArray = ADT( constants.GL_UNSIGNED_SHORT, constants.GLushort )
    GLuintArray = ADT( constants.GL_UNSIGNED_INT, constants.GLuint )
    GLint64Array = ADT( None, constants.GLint64 )
    GLuint64Array = ADT( constants.GL_UNSIGNED_INT64, constants.GLuint64 )
    GLenumArray = ADT( constants.GL_UNSIGNED_INT, constants.GLenum )
    GLsizeiArray = ADT( constants.GL_INT, constants.GLsizei )


GL_CONSTANT_TO_ARRAY_TYPE = {
    constants.GL_DOUBLE : GLclampdArray,
    constants.GL_FLOAT : GLclampfArray,
    constants.GL_FLOAT : GLfloatArray,
    constants.GL_DOUBLE : GLdoubleArray,
    constants.GL_BYTE : GLbyteArray,
    constants.GL_SHORT : GLshortArray,
    constants.GL_INT : GLintArray,
    constants.GL_UNSIGNED_BYTE : GLubyteArray,
    constants.GL_UNSIGNED_SHORT : GLushortArray,
    constants.GL_UNSIGNED_INT : GLuintArray,
    #constants.GL_UNSIGNED_INT : GLenumArray,
}
www.java2java.com | Contact Us
Copyright 2009 - 12 Demo Source and Support. All rights reserved.
All other trademarks are property of their respective owners.