OpenGL.arrays.arraydatatype
index
/build/buildd/pyopengl-3.0.0~b3/OpenGL/arrays/arraydatatype.py

Array data-type implementations (abstraction points for GL array types

 
Modules
       
OpenGL
OpenGL.constants
ctypes
OpenGL.arrays.formathandler
OpenGL.logs

 
Classes
       
object
ArrayDatatype
GLbyteArray(ArrayDatatype, ctypes.LP_c_byte)
GLcharArray(ArrayDatatype, c_char_p)
GLcharArray(ArrayDatatype, c_char_p)
GLclampdArray(ArrayDatatype, ctypes.LP_c_double)
GLclampfArray(ArrayDatatype, ctypes.LP_c_float)
GLdoubleArray(ArrayDatatype, ctypes.LP_c_double)
GLenumArray(ArrayDatatype, ctypes.LP_c_ulong)
GLfloatArray(ArrayDatatype, ctypes.LP_c_float)
GLintArray(ArrayDatatype, ctypes.LP_c_long)
GLshortArray(ArrayDatatype, ctypes.LP_c_short)
GLsizeiArray(ArrayDatatype, ctypes.LP_c_long)
GLubyteArray(ArrayDatatype, ctypes.LP_c_ubyte)
GLubyteArray(ArrayDatatype, ctypes.LP_c_ubyte)
GLuintArray(ArrayDatatype, ctypes.LP_c_ulong)
GLushortArray(ArrayDatatype, ctypes.LP_c_ushort)

 
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.
 
  Class methods defined here:
arrayByteCount(cls, value) from type
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
arraySize(cls, value, typeCode=None) from type
Given a data-value, calculate dimensions for the array (number-of-units)
arrayToGLType(cls, value) from type
Given a data-value, guess the OpenGL type of the corresponding pointer
asArray(cls, value, typeCode=None) from type
Given a value, convert to preferred array representation
dataPointer(cls, value) from type
Given a value in a known data-pointer type, return long for pointer
dimensions(cls, value) from type
Given a data-value, get the dimensions (assumes full structure info)
from_param(cls, value) from type
Given a value in a known data-pointer type, convert to a ctypes pointer
getHandler(cls, value) from type
Retrieve a handler for the given value, raise error on lookup failure
returnHandler(cls) from type
Get the default return-handler
typedPointer(cls, value) from type
Return a pointer-to-base-type pointer for given value
unitSize(cls, value, typeCode=None) from type
Determine unit size of an array (if possible)
 
Uses our local type if defined, otherwise asks the handler to guess...
voidDataPointer(cls, value) from type
Given value in a known data-pointer type, return void_p for pointer
zeros(cls, dims, typeCode=None) from type
Allocate a return array of the given dimensions filled with zeros

Data descriptors defined here:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

Data and other attributes defined here:
typeConstant = None

 
GLbooleanArray = class GLubyteArray(ArrayDatatype, ctypes.LP_c_ubyte)
    Array datatype for GLubyte types
 
 
Method resolution order:
GLubyteArray
ArrayDatatype
ctypes.LP_c_ubyte
_Pointer
_ctypes._CData
object

Data and other attributes defined here:
baseType = <class 'ctypes.c_ubyte'>
typeConstant = GL_UNSIGNED_BYTE

Class methods inherited from ArrayDatatype:
arrayByteCount(cls, value) from _ctypes.PointerType
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
arraySize(cls, value, typeCode=None) from _ctypes.PointerType
Given a data-value, calculate dimensions for the array (number-of-units)
arrayToGLType(cls, value) from _ctypes.PointerType
Given a data-value, guess the OpenGL type of the corresponding pointer
asArray(cls, value, typeCode=None) from _ctypes.PointerType
Given a value, convert to preferred array representation
dataPointer(cls, value) from _ctypes.PointerType
Given a value in a known data-pointer type, return long for pointer
dimensions(cls, value) from _ctypes.PointerType
Given a data-value, get the dimensions (assumes full structure info)
from_param(cls, value) from _ctypes.PointerType
Given a value in a known data-pointer type, convert to a ctypes pointer
getHandler(cls, value) from _ctypes.PointerType
Retrieve a handler for the given value, raise error on lookup failure
returnHandler(cls) from _ctypes.PointerType
Get the default return-handler
typedPointer(cls, value) from _ctypes.PointerType
Return a pointer-to-base-type pointer for given value
unitSize(cls, value, typeCode=None) from _ctypes.PointerType
Determine unit size of an array (if possible)
 
Uses our local type if defined, otherwise asks the handler to guess...
voidDataPointer(cls, value) from _ctypes.PointerType
Given value in a known data-pointer type, return void_p for pointer
zeros(cls, dims, typeCode=None) from _ctypes.PointerType
Allocate a return array of the given dimensions filled with zeros

Data descriptors inherited from ArrayDatatype:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

Methods inherited from _Pointer:
__delitem__(...)
x.__delitem__(y) <==> del x[y]
__getitem__(...)
x.__getitem__(y) <==> x[y]
__getslice__(...)
x.__getslice__(i, j) <==> x[i:j]
 
Use of negative indices is not supported.
__init__(...)
x.__init__(...) initializes x; see x.__class__.__doc__ for signature
__nonzero__(...)
x.__nonzero__() <==> x != 0
__setitem__(...)
x.__setitem__(i, y) <==> x[i]=y

Data descriptors inherited from _Pointer:
contents
the object this pointer points to (read-write)

Data and other attributes inherited from _Pointer:
__new__ = <built-in method __new__ of _ctypes.PointerType object at 0x4026a900>
T.__new__(S, ...) -> a new object with type S, a subtype of T

Methods inherited from _ctypes._CData:
__ctypes_from_outparam__(...)
__hash__(...)
x.__hash__() <==> hash(x)

 
class GLbyteArray(ArrayDatatype, ctypes.LP_c_byte)
    Array datatype for GLbyte types
 
 
Method resolution order:
GLbyteArray
ArrayDatatype
ctypes.LP_c_byte
_Pointer
_ctypes._CData
object

Data and other attributes defined here:
baseType = <class 'ctypes.c_byte'>
typeConstant = GL_BYTE

Class methods inherited from ArrayDatatype:
arrayByteCount(cls, value) from _ctypes.PointerType
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
arraySize(cls, value, typeCode=None) from _ctypes.PointerType
Given a data-value, calculate dimensions for the array (number-of-units)
arrayToGLType(cls, value) from _ctypes.PointerType
Given a data-value, guess the OpenGL type of the corresponding pointer
asArray(cls, value, typeCode=None) from _ctypes.PointerType
Given a value, convert to preferred array representation
dataPointer(cls, value) from _ctypes.PointerType
Given a value in a known data-pointer type, return long for pointer
dimensions(cls, value) from _ctypes.PointerType
Given a data-value, get the dimensions (assumes full structure info)
from_param(cls, value) from _ctypes.PointerType
Given a value in a known data-pointer type, convert to a ctypes pointer
getHandler(cls, value) from _ctypes.PointerType
Retrieve a handler for the given value, raise error on lookup failure
returnHandler(cls) from _ctypes.PointerType
Get the default return-handler
typedPointer(cls, value) from _ctypes.PointerType
Return a pointer-to-base-type pointer for given value
unitSize(cls, value, typeCode=None) from _ctypes.PointerType
Determine unit size of an array (if possible)
 
Uses our local type if defined, otherwise asks the handler to guess...
voidDataPointer(cls, value) from _ctypes.PointerType
Given value in a known data-pointer type, return void_p for pointer
zeros(cls, dims, typeCode=None) from _ctypes.PointerType
Allocate a return array of the given dimensions filled with zeros

Data descriptors inherited from ArrayDatatype:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

Methods inherited from _Pointer:
__delitem__(...)
x.__delitem__(y) <==> del x[y]
__getitem__(...)
x.__getitem__(y) <==> x[y]
__getslice__(...)
x.__getslice__(i, j) <==> x[i:j]
 
Use of negative indices is not supported.
__init__(...)
x.__init__(...) initializes x; see x.__class__.__doc__ for signature
__nonzero__(...)
x.__nonzero__() <==> x != 0
__setitem__(...)
x.__setitem__(i, y) <==> x[i]=y

Data descriptors inherited from _Pointer:
contents
the object this pointer points to (read-write)

Data and other attributes inherited from _Pointer:
__new__ = <built-in method __new__ of _ctypes.PointerType object at 0x4026a900>
T.__new__(S, ...) -> a new object with type S, a subtype of T

Methods inherited from _ctypes._CData:
__ctypes_from_outparam__(...)
__hash__(...)
x.__hash__() <==> hash(x)

 
GLcharARBArray = class GLcharArray(ArrayDatatype, c_char_p)
    Array datatype for ARB extension pointers-to-arrays
 
 
Method resolution order:
GLcharArray
ArrayDatatype
c_char_p
_SimpleCData
_ctypes._CData
object

Data and other attributes defined here:
baseType = <class 'ctypes.c_char'>
typeConstant = GL_BYTE

Class methods inherited from ArrayDatatype:
arrayByteCount(cls, value) from _ctypes.SimpleType
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
arraySize(cls, value, typeCode=None) from _ctypes.SimpleType
Given a data-value, calculate dimensions for the array (number-of-units)
arrayToGLType(cls, value) from _ctypes.SimpleType
Given a data-value, guess the OpenGL type of the corresponding pointer
asArray(cls, value, typeCode=None) from _ctypes.SimpleType
Given a value, convert to preferred array representation
dataPointer(cls, value) from _ctypes.SimpleType
Given a value in a known data-pointer type, return long for pointer
dimensions(cls, value) from _ctypes.SimpleType
Given a data-value, get the dimensions (assumes full structure info)
from_param(cls, value) from _ctypes.SimpleType
Given a value in a known data-pointer type, convert to a ctypes pointer
getHandler(cls, value) from _ctypes.SimpleType
Retrieve a handler for the given value, raise error on lookup failure
returnHandler(cls) from _ctypes.SimpleType
Get the default return-handler
typedPointer(cls, value) from _ctypes.SimpleType
Return a pointer-to-base-type pointer for given value
unitSize(cls, value, typeCode=None) from _ctypes.SimpleType
Determine unit size of an array (if possible)
 
Uses our local type if defined, otherwise asks the handler to guess...
voidDataPointer(cls, value) from _ctypes.SimpleType
Given value in a known data-pointer type, return void_p for pointer
zeros(cls, dims, typeCode=None) from _ctypes.SimpleType
Allocate a return array of the given dimensions filled with zeros

Data descriptors inherited from ArrayDatatype:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

Methods inherited from c_char_p:
__repr__(self)

Methods inherited from _SimpleCData:
__ctypes_from_outparam__(...)
__init__(...)
x.__init__(...) initializes x; see x.__class__.__doc__ for signature
__nonzero__(...)
x.__nonzero__() <==> x != 0

Data descriptors inherited from _SimpleCData:
value
current value

Data and other attributes inherited from _SimpleCData:
__new__ = <built-in method __new__ of _ctypes.SimpleType object at 0x4026a9c0>
T.__new__(S, ...) -> a new object with type S, a subtype of T

Methods inherited from _ctypes._CData:
__hash__(...)
x.__hash__() <==> hash(x)

 
class GLcharArray(ArrayDatatype, c_char_p)
    Array datatype for ARB extension pointers-to-arrays
 
 
Method resolution order:
GLcharArray
ArrayDatatype
c_char_p
_SimpleCData
_ctypes._CData
object

Data and other attributes defined here:
baseType = <class 'ctypes.c_char'>
typeConstant = GL_BYTE

Class methods inherited from ArrayDatatype:
arrayByteCount(cls, value) from _ctypes.SimpleType
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
arraySize(cls, value, typeCode=None) from _ctypes.SimpleType
Given a data-value, calculate dimensions for the array (number-of-units)
arrayToGLType(cls, value) from _ctypes.SimpleType
Given a data-value, guess the OpenGL type of the corresponding pointer
asArray(cls, value, typeCode=None) from _ctypes.SimpleType
Given a value, convert to preferred array representation
dataPointer(cls, value) from _ctypes.SimpleType
Given a value in a known data-pointer type, return long for pointer
dimensions(cls, value) from _ctypes.SimpleType
Given a data-value, get the dimensions (assumes full structure info)
from_param(cls, value) from _ctypes.SimpleType
Given a value in a known data-pointer type, convert to a ctypes pointer
getHandler(cls, value) from _ctypes.SimpleType
Retrieve a handler for the given value, raise error on lookup failure
returnHandler(cls) from _ctypes.SimpleType
Get the default return-handler
typedPointer(cls, value) from _ctypes.SimpleType
Return a pointer-to-base-type pointer for given value
unitSize(cls, value, typeCode=None) from _ctypes.SimpleType
Determine unit size of an array (if possible)
 
Uses our local type if defined, otherwise asks the handler to guess...
voidDataPointer(cls, value) from _ctypes.SimpleType
Given value in a known data-pointer type, return void_p for pointer
zeros(cls, dims, typeCode=None) from _ctypes.SimpleType
Allocate a return array of the given dimensions filled with zeros

Data descriptors inherited from ArrayDatatype:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

Methods inherited from c_char_p:
__repr__(self)

Methods inherited from _SimpleCData:
__ctypes_from_outparam__(...)
__init__(...)
x.__init__(...) initializes x; see x.__class__.__doc__ for signature
__nonzero__(...)
x.__nonzero__() <==> x != 0

Data descriptors inherited from _SimpleCData:
value
current value

Data and other attributes inherited from _SimpleCData:
__new__ = <built-in method __new__ of _ctypes.SimpleType object at 0x4026a9c0>
T.__new__(S, ...) -> a new object with type S, a subtype of T

Methods inherited from _ctypes._CData:
__hash__(...)
x.__hash__() <==> hash(x)

 
class GLclampdArray(ArrayDatatype, ctypes.LP_c_double)
    Array datatype for GLclampd types
 
 
Method resolution order:
GLclampdArray
ArrayDatatype
ctypes.LP_c_double
_Pointer
_ctypes._CData
object

Data and other attributes defined here:
baseType = <class 'ctypes.c_double'>
typeConstant = GL_DOUBLE

Class methods inherited from ArrayDatatype:
arrayByteCount(cls, value) from _ctypes.PointerType
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
arraySize(cls, value, typeCode=None) from _ctypes.PointerType
Given a data-value, calculate dimensions for the array (number-of-units)
arrayToGLType(cls, value) from _ctypes.PointerType
Given a data-value, guess the OpenGL type of the corresponding pointer
asArray(cls, value, typeCode=None) from _ctypes.PointerType
Given a value, convert to preferred array representation
dataPointer(cls, value) from _ctypes.PointerType
Given a value in a known data-pointer type, return long for pointer
dimensions(cls, value) from _ctypes.PointerType
Given a data-value, get the dimensions (assumes full structure info)
from_param(cls, value) from _ctypes.PointerType
Given a value in a known data-pointer type, convert to a ctypes pointer
getHandler(cls, value) from _ctypes.PointerType
Retrieve a handler for the given value, raise error on lookup failure
returnHandler(cls) from _ctypes.PointerType
Get the default return-handler
typedPointer(cls, value) from _ctypes.PointerType
Return a pointer-to-base-type pointer for given value
unitSize(cls, value, typeCode=None) from _ctypes.PointerType
Determine unit size of an array (if possible)
 
Uses our local type if defined, otherwise asks the handler to guess...
voidDataPointer(cls, value) from _ctypes.PointerType
Given value in a known data-pointer type, return void_p for pointer
zeros(cls, dims, typeCode=None) from _ctypes.PointerType
Allocate a return array of the given dimensions filled with zeros

Data descriptors inherited from ArrayDatatype:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

Methods inherited from _Pointer:
__delitem__(...)
x.__delitem__(y) <==> del x[y]
__getitem__(...)
x.__getitem__(y) <==> x[y]
__getslice__(...)
x.__getslice__(i, j) <==> x[i:j]
 
Use of negative indices is not supported.
__init__(...)
x.__init__(...) initializes x; see x.__class__.__doc__ for signature
__nonzero__(...)
x.__nonzero__() <==> x != 0
__setitem__(...)
x.__setitem__(i, y) <==> x[i]=y

Data descriptors inherited from _Pointer:
contents
the object this pointer points to (read-write)

Data and other attributes inherited from _Pointer:
__new__ = <built-in method __new__ of _ctypes.PointerType object at 0x4026a900>
T.__new__(S, ...) -> a new object with type S, a subtype of T

Methods inherited from _ctypes._CData:
__ctypes_from_outparam__(...)
__hash__(...)
x.__hash__() <==> hash(x)

 
class GLclampfArray(ArrayDatatype, ctypes.LP_c_float)
    Array datatype for GLclampf types
 
 
Method resolution order:
GLclampfArray
ArrayDatatype
ctypes.LP_c_float
_Pointer
_ctypes._CData
object

Data and other attributes defined here:
baseType = <class 'ctypes.c_float'>
typeConstant = GL_FLOAT

Class methods inherited from ArrayDatatype:
arrayByteCount(cls, value) from _ctypes.PointerType
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
arraySize(cls, value, typeCode=None) from _ctypes.PointerType
Given a data-value, calculate dimensions for the array (number-of-units)
arrayToGLType(cls, value) from _ctypes.PointerType
Given a data-value, guess the OpenGL type of the corresponding pointer
asArray(cls, value, typeCode=None) from _ctypes.PointerType
Given a value, convert to preferred array representation
dataPointer(cls, value) from _ctypes.PointerType
Given a value in a known data-pointer type, return long for pointer
dimensions(cls, value) from _ctypes.PointerType
Given a data-value, get the dimensions (assumes full structure info)
from_param(cls, value) from _ctypes.PointerType
Given a value in a known data-pointer type, convert to a ctypes pointer
getHandler(cls, value) from _ctypes.PointerType
Retrieve a handler for the given value, raise error on lookup failure
returnHandler(cls) from _ctypes.PointerType
Get the default return-handler
typedPointer(cls, value) from _ctypes.PointerType
Return a pointer-to-base-type pointer for given value
unitSize(cls, value, typeCode=None) from _ctypes.PointerType
Determine unit size of an array (if possible)
 
Uses our local type if defined, otherwise asks the handler to guess...
voidDataPointer(cls, value) from _ctypes.PointerType
Given value in a known data-pointer type, return void_p for pointer
zeros(cls, dims, typeCode=None) from _ctypes.PointerType
Allocate a return array of the given dimensions filled with zeros

Data descriptors inherited from ArrayDatatype:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

Methods inherited from _Pointer:
__delitem__(...)
x.__delitem__(y) <==> del x[y]
__getitem__(...)
x.__getitem__(y) <==> x[y]
__getslice__(...)
x.__getslice__(i, j) <==> x[i:j]
 
Use of negative indices is not supported.
__init__(...)
x.__init__(...) initializes x; see x.__class__.__doc__ for signature
__nonzero__(...)
x.__nonzero__() <==> x != 0
__setitem__(...)
x.__setitem__(i, y) <==> x[i]=y

Data descriptors inherited from _Pointer:
contents
the object this pointer points to (read-write)

Data and other attributes inherited from _Pointer:
__new__ = <built-in method __new__ of _ctypes.PointerType object at 0x4026a900>
T.__new__(S, ...) -> a new object with type S, a subtype of T

Methods inherited from _ctypes._CData:
__ctypes_from_outparam__(...)
__hash__(...)
x.__hash__() <==> hash(x)

 
class GLdoubleArray(ArrayDatatype, ctypes.LP_c_double)
    Array datatype for GLdouble types
 
 
Method resolution order:
GLdoubleArray
ArrayDatatype
ctypes.LP_c_double
_Pointer
_ctypes._CData
object

Data and other attributes defined here:
baseType = <class 'ctypes.c_double'>
typeConstant = GL_DOUBLE

Class methods inherited from ArrayDatatype:
arrayByteCount(cls, value) from _ctypes.PointerType
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
arraySize(cls, value, typeCode=None) from _ctypes.PointerType
Given a data-value, calculate dimensions for the array (number-of-units)
arrayToGLType(cls, value) from _ctypes.PointerType
Given a data-value, guess the OpenGL type of the corresponding pointer
asArray(cls, value, typeCode=None) from _ctypes.PointerType
Given a value, convert to preferred array representation
dataPointer(cls, value) from _ctypes.PointerType
Given a value in a known data-pointer type, return long for pointer
dimensions(cls, value) from _ctypes.PointerType
Given a data-value, get the dimensions (assumes full structure info)
from_param(cls, value) from _ctypes.PointerType
Given a value in a known data-pointer type, convert to a ctypes pointer
getHandler(cls, value) from _ctypes.PointerType
Retrieve a handler for the given value, raise error on lookup failure
returnHandler(cls) from _ctypes.PointerType
Get the default return-handler
typedPointer(cls, value) from _ctypes.PointerType
Return a pointer-to-base-type pointer for given value
unitSize(cls, value, typeCode=None) from _ctypes.PointerType
Determine unit size of an array (if possible)
 
Uses our local type if defined, otherwise asks the handler to guess...
voidDataPointer(cls, value) from _ctypes.PointerType
Given value in a known data-pointer type, return void_p for pointer
zeros(cls, dims, typeCode=None) from _ctypes.PointerType
Allocate a return array of the given dimensions filled with zeros

Data descriptors inherited from ArrayDatatype:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

Methods inherited from _Pointer:
__delitem__(...)
x.__delitem__(y) <==> del x[y]
__getitem__(...)
x.__getitem__(y) <==> x[y]
__getslice__(...)
x.__getslice__(i, j) <==> x[i:j]
 
Use of negative indices is not supported.
__init__(...)
x.__init__(...) initializes x; see x.__class__.__doc__ for signature
__nonzero__(...)
x.__nonzero__() <==> x != 0
__setitem__(...)
x.__setitem__(i, y) <==> x[i]=y

Data descriptors inherited from _Pointer:
contents
the object this pointer points to (read-write)

Data and other attributes inherited from _Pointer:
__new__ = <built-in method __new__ of _ctypes.PointerType object at 0x4026a900>
T.__new__(S, ...) -> a new object with type S, a subtype of T

Methods inherited from _ctypes._CData:
__ctypes_from_outparam__(...)
__hash__(...)
x.__hash__() <==> hash(x)

 
class GLenumArray(ArrayDatatype, ctypes.LP_c_ulong)
    Array datatype for GLenum types
 
 
Method resolution order:
GLenumArray
ArrayDatatype
ctypes.LP_c_ulong
_Pointer
_ctypes._CData
object

Data and other attributes defined here:
baseType = <class 'ctypes.c_ulong'>
typeConstant = GL_UNSIGNED_INT

Class methods inherited from ArrayDatatype:
arrayByteCount(cls, value) from _ctypes.PointerType
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
arraySize(cls, value, typeCode=None) from _ctypes.PointerType
Given a data-value, calculate dimensions for the array (number-of-units)
arrayToGLType(cls, value) from _ctypes.PointerType
Given a data-value, guess the OpenGL type of the corresponding pointer
asArray(cls, value, typeCode=None) from _ctypes.PointerType
Given a value, convert to preferred array representation
dataPointer(cls, value) from _ctypes.PointerType
Given a value in a known data-pointer type, return long for pointer
dimensions(cls, value) from _ctypes.PointerType
Given a data-value, get the dimensions (assumes full structure info)
from_param(cls, value) from _ctypes.PointerType
Given a value in a known data-pointer type, convert to a ctypes pointer
getHandler(cls, value) from _ctypes.PointerType
Retrieve a handler for the given value, raise error on lookup failure
returnHandler(cls) from _ctypes.PointerType
Get the default return-handler
typedPointer(cls, value) from _ctypes.PointerType
Return a pointer-to-base-type pointer for given value
unitSize(cls, value, typeCode=None) from _ctypes.PointerType
Determine unit size of an array (if possible)
 
Uses our local type if defined, otherwise asks the handler to guess...
voidDataPointer(cls, value) from _ctypes.PointerType
Given value in a known data-pointer type, return void_p for pointer
zeros(cls, dims, typeCode=None) from _ctypes.PointerType
Allocate a return array of the given dimensions filled with zeros

Data descriptors inherited from ArrayDatatype:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

Methods inherited from _Pointer:
__delitem__(...)
x.__delitem__(y) <==> del x[y]
__getitem__(...)
x.__getitem__(y) <==> x[y]
__getslice__(...)
x.__getslice__(i, j) <==> x[i:j]
 
Use of negative indices is not supported.
__init__(...)
x.__init__(...) initializes x; see x.__class__.__doc__ for signature
__nonzero__(...)
x.__nonzero__() <==> x != 0
__setitem__(...)
x.__setitem__(i, y) <==> x[i]=y

Data descriptors inherited from _Pointer:
contents
the object this pointer points to (read-write)

Data and other attributes inherited from _Pointer:
__new__ = <built-in method __new__ of _ctypes.PointerType object at 0x4026a900>
T.__new__(S, ...) -> a new object with type S, a subtype of T

Methods inherited from _ctypes._CData:
__ctypes_from_outparam__(...)
__hash__(...)
x.__hash__() <==> hash(x)

 
class GLfloatArray(ArrayDatatype, ctypes.LP_c_float)
    Array datatype for GLfloat types
 
 
Method resolution order:
GLfloatArray
ArrayDatatype
ctypes.LP_c_float
_Pointer
_ctypes._CData
object

Data and other attributes defined here:
baseType = <class 'ctypes.c_float'>
typeConstant = GL_FLOAT

Class methods inherited from ArrayDatatype:
arrayByteCount(cls, value) from _ctypes.PointerType
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
arraySize(cls, value, typeCode=None) from _ctypes.PointerType
Given a data-value, calculate dimensions for the array (number-of-units)
arrayToGLType(cls, value) from _ctypes.PointerType
Given a data-value, guess the OpenGL type of the corresponding pointer
asArray(cls, value, typeCode=None) from _ctypes.PointerType
Given a value, convert to preferred array representation
dataPointer(cls, value) from _ctypes.PointerType
Given a value in a known data-pointer type, return long for pointer
dimensions(cls, value) from _ctypes.PointerType
Given a data-value, get the dimensions (assumes full structure info)
from_param(cls, value) from _ctypes.PointerType
Given a value in a known data-pointer type, convert to a ctypes pointer
getHandler(cls, value) from _ctypes.PointerType
Retrieve a handler for the given value, raise error on lookup failure
returnHandler(cls) from _ctypes.PointerType
Get the default return-handler
typedPointer(cls, value) from _ctypes.PointerType
Return a pointer-to-base-type pointer for given value
unitSize(cls, value, typeCode=None) from _ctypes.PointerType
Determine unit size of an array (if possible)
 
Uses our local type if defined, otherwise asks the handler to guess...
voidDataPointer(cls, value) from _ctypes.PointerType
Given value in a known data-pointer type, return void_p for pointer
zeros(cls, dims, typeCode=None) from _ctypes.PointerType
Allocate a return array of the given dimensions filled with zeros

Data descriptors inherited from ArrayDatatype:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

Methods inherited from _Pointer:
__delitem__(...)
x.__delitem__(y) <==> del x[y]
__getitem__(...)
x.__getitem__(y) <==> x[y]
__getslice__(...)
x.__getslice__(i, j) <==> x[i:j]
 
Use of negative indices is not supported.
__init__(...)
x.__init__(...) initializes x; see x.__class__.__doc__ for signature
__nonzero__(...)
x.__nonzero__() <==> x != 0
__setitem__(...)
x.__setitem__(i, y) <==> x[i]=y

Data descriptors inherited from _Pointer:
contents
the object this pointer points to (read-write)

Data and other attributes inherited from _Pointer:
__new__ = <built-in method __new__ of _ctypes.PointerType object at 0x4026a900>
T.__new__(S, ...) -> a new object with type S, a subtype of T

Methods inherited from _ctypes._CData:
__ctypes_from_outparam__(...)
__hash__(...)
x.__hash__() <==> hash(x)

 
class GLintArray(ArrayDatatype, ctypes.LP_c_long)
    Array datatype for GLint types
 
 
Method resolution order:
GLintArray
ArrayDatatype
ctypes.LP_c_long
_Pointer
_ctypes._CData
object

Data and other attributes defined here:
baseType = <class 'ctypes.c_long'>
typeConstant = GL_INT

Class methods inherited from ArrayDatatype:
arrayByteCount(cls, value) from _ctypes.PointerType
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
arraySize(cls, value, typeCode=None) from _ctypes.PointerType
Given a data-value, calculate dimensions for the array (number-of-units)
arrayToGLType(cls, value) from _ctypes.PointerType
Given a data-value, guess the OpenGL type of the corresponding pointer
asArray(cls, value, typeCode=None) from _ctypes.PointerType
Given a value, convert to preferred array representation
dataPointer(cls, value) from _ctypes.PointerType
Given a value in a known data-pointer type, return long for pointer
dimensions(cls, value) from _ctypes.PointerType
Given a data-value, get the dimensions (assumes full structure info)
from_param(cls, value) from _ctypes.PointerType
Given a value in a known data-pointer type, convert to a ctypes pointer
getHandler(cls, value) from _ctypes.PointerType
Retrieve a handler for the given value, raise error on lookup failure
returnHandler(cls) from _ctypes.PointerType
Get the default return-handler
typedPointer(cls, value) from _ctypes.PointerType
Return a pointer-to-base-type pointer for given value
unitSize(cls, value, typeCode=None) from _ctypes.PointerType
Determine unit size of an array (if possible)
 
Uses our local type if defined, otherwise asks the handler to guess...
voidDataPointer(cls, value) from _ctypes.PointerType
Given value in a known data-pointer type, return void_p for pointer
zeros(cls, dims, typeCode=None) from _ctypes.PointerType
Allocate a return array of the given dimensions filled with zeros

Data descriptors inherited from ArrayDatatype:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

Methods inherited from _Pointer:
__delitem__(...)
x.__delitem__(y) <==> del x[y]
__getitem__(...)
x.__getitem__(y) <==> x[y]
__getslice__(...)
x.__getslice__(i, j) <==> x[i:j]
 
Use of negative indices is not supported.
__init__(...)
x.__init__(...) initializes x; see x.__class__.__doc__ for signature
__nonzero__(...)
x.__nonzero__() <==> x != 0
__setitem__(...)
x.__setitem__(i, y) <==> x[i]=y

Data descriptors inherited from _Pointer:
contents
the object this pointer points to (read-write)

Data and other attributes inherited from _Pointer:
__new__ = <built-in method __new__ of _ctypes.PointerType object at 0x4026a900>
T.__new__(S, ...) -> a new object with type S, a subtype of T

Methods inherited from _ctypes._CData:
__ctypes_from_outparam__(...)
__hash__(...)
x.__hash__() <==> hash(x)

 
class GLshortArray(ArrayDatatype, ctypes.LP_c_short)
    Array datatype for GLshort types
 
 
Method resolution order:
GLshortArray
ArrayDatatype
ctypes.LP_c_short
_Pointer
_ctypes._CData
object

Data and other attributes defined here:
baseType = <class 'ctypes.c_short'>
typeConstant = GL_SHORT

Class methods inherited from ArrayDatatype:
arrayByteCount(cls, value) from _ctypes.PointerType
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
arraySize(cls, value, typeCode=None) from _ctypes.PointerType
Given a data-value, calculate dimensions for the array (number-of-units)
arrayToGLType(cls, value) from _ctypes.PointerType
Given a data-value, guess the OpenGL type of the corresponding pointer
asArray(cls, value, typeCode=None) from _ctypes.PointerType
Given a value, convert to preferred array representation
dataPointer(cls, value) from _ctypes.PointerType
Given a value in a known data-pointer type, return long for pointer
dimensions(cls, value) from _ctypes.PointerType
Given a data-value, get the dimensions (assumes full structure info)
from_param(cls, value) from _ctypes.PointerType
Given a value in a known data-pointer type, convert to a ctypes pointer
getHandler(cls, value) from _ctypes.PointerType
Retrieve a handler for the given value, raise error on lookup failure
returnHandler(cls) from _ctypes.PointerType
Get the default return-handler
typedPointer(cls, value) from _ctypes.PointerType
Return a pointer-to-base-type pointer for given value
unitSize(cls, value, typeCode=None) from _ctypes.PointerType
Determine unit size of an array (if possible)
 
Uses our local type if defined, otherwise asks the handler to guess...
voidDataPointer(cls, value) from _ctypes.PointerType
Given value in a known data-pointer type, return void_p for pointer
zeros(cls, dims, typeCode=None) from _ctypes.PointerType
Allocate a return array of the given dimensions filled with zeros

Data descriptors inherited from ArrayDatatype:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

Methods inherited from _Pointer:
__delitem__(...)
x.__delitem__(y) <==> del x[y]
__getitem__(...)
x.__getitem__(y) <==> x[y]
__getslice__(...)
x.__getslice__(i, j) <==> x[i:j]
 
Use of negative indices is not supported.
__init__(...)
x.__init__(...) initializes x; see x.__class__.__doc__ for signature
__nonzero__(...)
x.__nonzero__() <==> x != 0
__setitem__(...)
x.__setitem__(i, y) <==> x[i]=y

Data descriptors inherited from _Pointer:
contents
the object this pointer points to (read-write)

Data and other attributes inherited from _Pointer:
__new__ = <built-in method __new__ of _ctypes.PointerType object at 0x4026a900>
T.__new__(S, ...) -> a new object with type S, a subtype of T

Methods inherited from _ctypes._CData:
__ctypes_from_outparam__(...)
__hash__(...)
x.__hash__() <==> hash(x)

 
class GLsizeiArray(ArrayDatatype, ctypes.LP_c_long)
    Array datatype for GLenum types
 
 
Method resolution order:
GLsizeiArray
ArrayDatatype
ctypes.LP_c_long
_Pointer
_ctypes._CData
object

Data and other attributes defined here:
baseType = <class 'ctypes.c_long'>
typeConstant = GL_INT

Class methods inherited from ArrayDatatype:
arrayByteCount(cls, value) from _ctypes.PointerType
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
arraySize(cls, value, typeCode=None) from _ctypes.PointerType
Given a data-value, calculate dimensions for the array (number-of-units)
arrayToGLType(cls, value) from _ctypes.PointerType
Given a data-value, guess the OpenGL type of the corresponding pointer
asArray(cls, value, typeCode=None) from _ctypes.PointerType
Given a value, convert to preferred array representation
dataPointer(cls, value) from _ctypes.PointerType
Given a value in a known data-pointer type, return long for pointer
dimensions(cls, value) from _ctypes.PointerType
Given a data-value, get the dimensions (assumes full structure info)
from_param(cls, value) from _ctypes.PointerType
Given a value in a known data-pointer type, convert to a ctypes pointer
getHandler(cls, value) from _ctypes.PointerType
Retrieve a handler for the given value, raise error on lookup failure
returnHandler(cls) from _ctypes.PointerType
Get the default return-handler
typedPointer(cls, value) from _ctypes.PointerType
Return a pointer-to-base-type pointer for given value
unitSize(cls, value, typeCode=None) from _ctypes.PointerType
Determine unit size of an array (if possible)
 
Uses our local type if defined, otherwise asks the handler to guess...
voidDataPointer(cls, value) from _ctypes.PointerType
Given value in a known data-pointer type, return void_p for pointer
zeros(cls, dims, typeCode=None) from _ctypes.PointerType
Allocate a return array of the given dimensions filled with zeros

Data descriptors inherited from ArrayDatatype:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

Methods inherited from _Pointer:
__delitem__(...)
x.__delitem__(y) <==> del x[y]
__getitem__(...)
x.__getitem__(y) <==> x[y]
__getslice__(...)
x.__getslice__(i, j) <==> x[i:j]
 
Use of negative indices is not supported.
__init__(...)
x.__init__(...) initializes x; see x.__class__.__doc__ for signature
__nonzero__(...)
x.__nonzero__() <==> x != 0
__setitem__(...)
x.__setitem__(i, y) <==> x[i]=y

Data descriptors inherited from _Pointer:
contents
the object this pointer points to (read-write)

Data and other attributes inherited from _Pointer:
__new__ = <built-in method __new__ of _ctypes.PointerType object at 0x4026a900>
T.__new__(S, ...) -> a new object with type S, a subtype of T

Methods inherited from _ctypes._CData:
__ctypes_from_outparam__(...)
__hash__(...)
x.__hash__() <==> hash(x)

 
class GLubyteArray(ArrayDatatype, ctypes.LP_c_ubyte)
    Array datatype for GLubyte types
 
 
Method resolution order:
GLubyteArray
ArrayDatatype
ctypes.LP_c_ubyte
_Pointer
_ctypes._CData
object

Data and other attributes defined here:
baseType = <class 'ctypes.c_ubyte'>
typeConstant = GL_UNSIGNED_BYTE

Class methods inherited from ArrayDatatype:
arrayByteCount(cls, value) from _ctypes.PointerType
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
arraySize(cls, value, typeCode=None) from _ctypes.PointerType
Given a data-value, calculate dimensions for the array (number-of-units)
arrayToGLType(cls, value) from _ctypes.PointerType
Given a data-value, guess the OpenGL type of the corresponding pointer
asArray(cls, value, typeCode=None) from _ctypes.PointerType
Given a value, convert to preferred array representation
dataPointer(cls, value) from _ctypes.PointerType
Given a value in a known data-pointer type, return long for pointer
dimensions(cls, value) from _ctypes.PointerType
Given a data-value, get the dimensions (assumes full structure info)
from_param(cls, value) from _ctypes.PointerType
Given a value in a known data-pointer type, convert to a ctypes pointer
getHandler(cls, value) from _ctypes.PointerType
Retrieve a handler for the given value, raise error on lookup failure
returnHandler(cls) from _ctypes.PointerType
Get the default return-handler
typedPointer(cls, value) from _ctypes.PointerType
Return a pointer-to-base-type pointer for given value
unitSize(cls, value, typeCode=None) from _ctypes.PointerType
Determine unit size of an array (if possible)
 
Uses our local type if defined, otherwise asks the handler to guess...
voidDataPointer(cls, value) from _ctypes.PointerType
Given value in a known data-pointer type, return void_p for pointer
zeros(cls, dims, typeCode=None) from _ctypes.PointerType
Allocate a return array of the given dimensions filled with zeros

Data descriptors inherited from ArrayDatatype:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

Methods inherited from _Pointer:
__delitem__(...)
x.__delitem__(y) <==> del x[y]
__getitem__(...)
x.__getitem__(y) <==> x[y]
__getslice__(...)
x.__getslice__(i, j) <==> x[i:j]
 
Use of negative indices is not supported.
__init__(...)
x.__init__(...) initializes x; see x.__class__.__doc__ for signature
__nonzero__(...)
x.__nonzero__() <==> x != 0
__setitem__(...)
x.__setitem__(i, y) <==> x[i]=y

Data descriptors inherited from _Pointer:
contents
the object this pointer points to (read-write)

Data and other attributes inherited from _Pointer:
__new__ = <built-in method __new__ of _ctypes.PointerType object at 0x4026a900>
T.__new__(S, ...) -> a new object with type S, a subtype of T

Methods inherited from _ctypes._CData:
__ctypes_from_outparam__(...)
__hash__(...)
x.__hash__() <==> hash(x)

 
class GLuintArray(ArrayDatatype, ctypes.LP_c_ulong)
    Array datatype for GLuint types
 
 
Method resolution order:
GLuintArray
ArrayDatatype
ctypes.LP_c_ulong
_Pointer
_ctypes._CData
object

Data and other attributes defined here:
baseType = <class 'ctypes.c_ulong'>
typeConstant = GL_UNSIGNED_INT

Class methods inherited from ArrayDatatype:
arrayByteCount(cls, value) from _ctypes.PointerType
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
arraySize(cls, value, typeCode=None) from _ctypes.PointerType
Given a data-value, calculate dimensions for the array (number-of-units)
arrayToGLType(cls, value) from _ctypes.PointerType
Given a data-value, guess the OpenGL type of the corresponding pointer
asArray(cls, value, typeCode=None) from _ctypes.PointerType
Given a value, convert to preferred array representation
dataPointer(cls, value) from _ctypes.PointerType
Given a value in a known data-pointer type, return long for pointer
dimensions(cls, value) from _ctypes.PointerType
Given a data-value, get the dimensions (assumes full structure info)
from_param(cls, value) from _ctypes.PointerType
Given a value in a known data-pointer type, convert to a ctypes pointer
getHandler(cls, value) from _ctypes.PointerType
Retrieve a handler for the given value, raise error on lookup failure
returnHandler(cls) from _ctypes.PointerType
Get the default return-handler
typedPointer(cls, value) from _ctypes.PointerType
Return a pointer-to-base-type pointer for given value
unitSize(cls, value, typeCode=None) from _ctypes.PointerType
Determine unit size of an array (if possible)
 
Uses our local type if defined, otherwise asks the handler to guess...
voidDataPointer(cls, value) from _ctypes.PointerType
Given value in a known data-pointer type, return void_p for pointer
zeros(cls, dims, typeCode=None) from _ctypes.PointerType
Allocate a return array of the given dimensions filled with zeros

Data descriptors inherited from ArrayDatatype:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

Methods inherited from _Pointer:
__delitem__(...)
x.__delitem__(y) <==> del x[y]
__getitem__(...)
x.__getitem__(y) <==> x[y]
__getslice__(...)
x.__getslice__(i, j) <==> x[i:j]
 
Use of negative indices is not supported.
__init__(...)
x.__init__(...) initializes x; see x.__class__.__doc__ for signature
__nonzero__(...)
x.__nonzero__() <==> x != 0
__setitem__(...)
x.__setitem__(i, y) <==> x[i]=y

Data descriptors inherited from _Pointer:
contents
the object this pointer points to (read-write)

Data and other attributes inherited from _Pointer:
__new__ = <built-in method __new__ of _ctypes.PointerType object at 0x4026a900>
T.__new__(S, ...) -> a new object with type S, a subtype of T

Methods inherited from _ctypes._CData:
__ctypes_from_outparam__(...)
__hash__(...)
x.__hash__() <==> hash(x)

 
class GLushortArray(ArrayDatatype, ctypes.LP_c_ushort)
    Array datatype for GLushort types
 
 
Method resolution order:
GLushortArray
ArrayDatatype
ctypes.LP_c_ushort
_Pointer
_ctypes._CData
object

Data and other attributes defined here:
baseType = <class 'ctypes.c_ushort'>
typeConstant = GL_UNSIGNED_SHORT

Class methods inherited from ArrayDatatype:
arrayByteCount(cls, value) from _ctypes.PointerType
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
arraySize(cls, value, typeCode=None) from _ctypes.PointerType
Given a data-value, calculate dimensions for the array (number-of-units)
arrayToGLType(cls, value) from _ctypes.PointerType
Given a data-value, guess the OpenGL type of the corresponding pointer
asArray(cls, value, typeCode=None) from _ctypes.PointerType
Given a value, convert to preferred array representation
dataPointer(cls, value) from _ctypes.PointerType
Given a value in a known data-pointer type, return long for pointer
dimensions(cls, value) from _ctypes.PointerType
Given a data-value, get the dimensions (assumes full structure info)
from_param(cls, value) from _ctypes.PointerType
Given a value in a known data-pointer type, convert to a ctypes pointer
getHandler(cls, value) from _ctypes.PointerType
Retrieve a handler for the given value, raise error on lookup failure
returnHandler(cls) from _ctypes.PointerType
Get the default return-handler
typedPointer(cls, value) from _ctypes.PointerType
Return a pointer-to-base-type pointer for given value
unitSize(cls, value, typeCode=None) from _ctypes.PointerType
Determine unit size of an array (if possible)
 
Uses our local type if defined, otherwise asks the handler to guess...
voidDataPointer(cls, value) from _ctypes.PointerType
Given value in a known data-pointer type, return void_p for pointer
zeros(cls, dims, typeCode=None) from _ctypes.PointerType
Allocate a return array of the given dimensions filled with zeros

Data descriptors inherited from ArrayDatatype:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

Methods inherited from _Pointer:
__delitem__(...)
x.__delitem__(y) <==> del x[y]
__getitem__(...)
x.__getitem__(y) <==> x[y]
__getslice__(...)
x.__getslice__(i, j) <==> x[i:j]
 
Use of negative indices is not supported.
__init__(...)
x.__init__(...) initializes x; see x.__class__.__doc__ for signature
__nonzero__(...)
x.__nonzero__() <==> x != 0
__setitem__(...)
x.__setitem__(i, y) <==> x[i]=y

Data descriptors inherited from _Pointer:
contents
the object this pointer points to (read-write)

Data and other attributes inherited from _Pointer:
__new__ = <built-in method __new__ of _ctypes.PointerType object at 0x4026a900>
T.__new__(S, ...) -> a new object with type S, a subtype of T

Methods inherited from _ctypes._CData:
__ctypes_from_outparam__(...)
__hash__(...)
x.__hash__() <==> hash(x)

 
Data
        GL_CONSTANT_TO_ARRAY_TYPE = {GL_BYTE: <class 'OpenGL.arrays.arraydatatype.GLbyteArray'>, GL_UNSIGNED_BYTE: <class 'OpenGL.arrays.arraydatatype.GLubyteArray'>, GL_SHORT: <class 'OpenGL.arrays.arraydatatype.GLshortArray'>, GL_UNSIGNED_SHORT: <class 'OpenGL.arrays.arraydatatype.GLushortArray'>, GL_INT: <class 'OpenGL.arrays.arraydatatype.GLintArray'>, GL_UNSIGNED_INT: <class 'OpenGL.arrays.arraydatatype.GLuintArray'>, GL_FLOAT: <class 'OpenGL.arrays.arraydatatype.GLfloatArray'>, GL_DOUBLE: <class 'OpenGL.arrays.arraydatatype.GLdoubleArray'>}
__file__ = '/build/buildd/pyopengl-3.0.0~b3/OpenGL/arrays/arraydatatype.py'
__name__ = 'OpenGL.arrays.arraydatatype'
log = <logging.Logger instance at 0x822f2ac>