| |
- 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)
| |