@_lazy( glBufferData )
def glBufferData( baseOperation, target, size, data=None, usage=None ):
    """Copy given data into the currently bound vertex-buffer-data object

    target -- the symbolic constant indicating which buffer type is intended
    size -- if provided, the count-in-bytes of the array
    data -- data-pointer to be used, may be None to initialize without
        copying over a data-set
    usage -- hint to the driver as to how to set up access to the buffer

    Note: parameter "size" can be omitted, which makes the signature
        glBufferData( target, data, usage )
    instead of:
        glBufferData( target, size, data, usage )
    """
    if usage is None:
        usage = data
        data = size
        size = None
    data = ArrayDatatype.asArray( data ) # <- ここでPythonの型をOpenGLに渡せるように変換
    if size is None:
        size = ArrayDatatype.arrayByteCount( data )
    return baseOperation( target, size, data, usage )

class HandlerRegistry( dict ):
    def __init__( self, plugin_match ):
        self.match = plugin_match

    def __call__( self, value ): # 4
        """Lookup of handler for given value"""
        try:
            typ = value.__class__
        except AttributeError as 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 ) # 5
                        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 %s.%s (value: %s) registered"""%(
                        typ.__module__, type.__name__, repr(value)[:50]
                        )
                    )
            return handler

GLOBAL_REGISTRY = HandlerRegistry(
    plugins.FormatHandler.match # 6 -> plugins.pyに進む
    ) # 3
class ArrayDatatype( object ):
    getHandler = GLOBAL_REGISTRY.__call__ # 2
    def asArray( cls, value, typeCode=None ): # 0 <- glBufferDataから呼ばれる
        """Given a value, convert to preferred array representation"""
        return cls.getHandler(value).asArray( value, typeCode or cls.typeConstant ) # 1
    asArray = classmethod( logs.logOnFail( asArray, _log ) )

class Plugin( object ):
    """Base class for plugins to be loaded"""
    loaded = False
    def __init__( self, name, import_path, check = None, **named ):
        """Register the plug-in"""
        self.registry.append( self ) # <-  FormatHandlerのインスタンスが登録される

class FormatHandler( Plugin ):
    """Data-type storage-format handler"""
    registry = [] # <- OpenGL/__init__.pyで初期化される
    @classmethod
    def match( cls, value ): # 7
        """Lookup appropriate handler based on value (a type)"""
        key = '%s.%s'%( value.__module__, value.__name__ )
        for plugin in cls.registry: # <- ここにハンドラのリストがある
            set = getattr( plugin, 'check', ())
            if set and key in set:
                return plugin
        return None

FormatHandler( 'none', 'OpenGL.arrays.nones.NoneHandler', [ _bi+'.NoneType'],isOutput=False )

if sys.version_info[0] < 3:
    FormatHandler( 'str', 'OpenGL.arrays.strings.StringHandler',[_bi+'.str'], isOutput=False )
    FormatHandler( 'unicode', 'OpenGL.arrays.strings.UnicodeHandler',[_bi+'.unicode'], isOutput=False )
else:
    FormatHandler( 'bytes', 'OpenGL.arrays.strings.StringHandler',[_bi+'.bytes'], isOutput=False )
    FormatHandler( 'str', 'OpenGL.arrays.strings.UnicodeHandler',[_bi+'.str'], isOutput=False )

FormatHandler( 'list', 'OpenGL.arrays.lists.ListHandler', [
    _bi+'.list',
    _bi+'.tuple',
], isOutput=False )
FormatHandler( 'numbers', 'OpenGL.arrays.numbers.NumberHandler', [
    _bi+'.int',
    _bi+'.float',
    _bi+'.long',
], isOutput=False )
FormatHandler(
    'ctypesarrays', 'OpenGL.arrays.ctypesarrays.CtypesArrayHandler',
    [
        '_ctypes.ArrayType',
        '_ctypes.PyCArrayType',
        '_ctypes.Array',
        '_ctypes.array.Array',
    ],
    isOutput=True,
)
FormatHandler(
    'ctypesparameter',
    'OpenGL.arrays.ctypesparameters.CtypesParameterHandler',
    [
        _bi+'.CArgObject',
        'ctypes.c_uint',
        'ctypes.c_int',
        'ctypes.c_float',
        'ctypes.c_double',
        'ctypes.c_ulong',
        'ctypes.c_long',
        'ctypes.c_longlong',
    ],
    isOutput=True,
)
FormatHandler( 'ctypespointer', 'OpenGL.arrays.ctypespointers.CtypesPointerHandler',[
    'ctypes.c_void_p',
    '_ctypes._Pointer',
    'ctypes.c_char_p',
    '_ctypes.pointer._Pointer',
],isOutput=False )
FormatHandler( 'numpy', 'OpenGL.arrays.numpymodule.NumpyHandler', [
    'numpy.ndarray',
    'numpy.core.memmap.memmap',
],isOutput=True )
FormatHandler( 'buffer', 'OpenGL.arrays.buffers.BufferHandler', [
    'OpenGL.arrays._buffers.Py_buffer',
    _bi+'.memoryview',
    _bi+'.bytearray',
],isOutput=True )
FormatHandler( 'vbo', 'OpenGL.arrays.vbo.VBOHandler', ['OpenGL.arrays.vbo.VBO','OpenGL_accelerate.vbo.VBO'],isOutput=False )
FormatHandler( 'vbooffset', 'OpenGL.arrays.vbo.VBOOffsetHandler', ['OpenGL.arrays.vbo.VBOOffset','OpenGL_accelerate.vbo.VBOOffset'],isOutput=False )