OpenGL.GL.pointers
index
/var/pylive/OpenGL-ctypes/OpenGL/GL/pointers.py

Implementations for "held-pointers" of various types
 
This argument type is special because it is stored, that is, it 
needs to be cached on our side so that the memory address does not
go out-of-scope
 
storedPointers = {}
def glVertexPointerd( array ):
        "Natural writing of glVertexPointerd using standard ctypes"
        arg2 = GL_DOUBLE
        arg3 = 0 # stride
        arg4 = arrays.asArray(array, GL_DOUBLE)
        arg1 = arrays.arraySize( arg4, 'd' )
        platform.OpenGL.glVertexPointer( arg1, arg2, arg3, arrays.ArrayDatatype.dataPointer(arg4) )
        glCheckError()
        # only store if we successfully set the value...
        storedPointers[ GL_VERTEX_ARRAY ] = arg4
        return arg4

 
Modules
       
OpenGL.raw.GL.annotations
OpenGL.arrays
OpenGL.constant
OpenGL.contextdata
OpenGL.converters
ctypes
OpenGL.error
OpenGL.platform
OpenGL.raw.GL
weakref
OpenGL.wrapper

 
Functions
        glColorPointer( size,type,stride,pointer )
pyConverters: size=None, type=None, stride=None, pointer=<OpenGL.arrays.arrayhelpers.AsArrayOfType object>
cConverters: Not Used
cResolvers: size=None, type=None, stride=None, pointer=
voidDataPointer(cls, value) method of type instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object>
returnValues: <OpenGL.converters.returnPyArgument object>
Wrapping Operation: glColorPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glColorPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object>
cConverters: size=
arraySizeOfFirst(pyArgs, index, baseOperation)
Return the array size of the first argument
, type=GL_BYTE, stride=0, pointer=<OpenGL.converters.getPyArgsName object>
cResolvers: size=None, type=None, stride=None, pointer=
voidDataPointer(cls, value) method of _ctypes.PointerType instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object>
returnValues: <OpenGL.converters.returnPyArgument object>
Wrapping Operation: glColorPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glColorPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object>
cConverters: size=
arraySizeOfFirst(pyArgs, index, baseOperation)
Return the array size of the first argument
, type=GL_DOUBLE, stride=0, pointer=<OpenGL.converters.getPyArgsName object>
cResolvers: size=None, type=None, stride=None, pointer=
voidDataPointer(cls, value) method of _ctypes.PointerType instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object>
returnValues: <OpenGL.converters.returnPyArgument object>
Wrapping Operation: glColorPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glColorPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object>
cConverters: size=
arraySizeOfFirst(pyArgs, index, baseOperation)
Return the array size of the first argument
, type=GL_FLOAT, stride=0, pointer=<OpenGL.converters.getPyArgsName object>
cResolvers: size=None, type=None, stride=None, pointer=
voidDataPointer(cls, value) method of _ctypes.PointerType instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object>
returnValues: <OpenGL.converters.returnPyArgument object>
Wrapping Operation: glColorPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glColorPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object>
cConverters: size=
arraySizeOfFirst(pyArgs, index, baseOperation)
Return the array size of the first argument
, type=GL_INT, stride=0, pointer=<OpenGL.converters.getPyArgsName object>
cResolvers: size=None, type=None, stride=None, pointer=
voidDataPointer(cls, value) method of _ctypes.PointerType instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object>
returnValues: <OpenGL.converters.returnPyArgument object>
Wrapping Operation: glColorPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glColorPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object>
cConverters: size=
arraySizeOfFirst(pyArgs, index, baseOperation)
Return the array size of the first argument
, type=GL_SHORT, stride=0, pointer=<OpenGL.converters.getPyArgsName object>
cResolvers: size=None, type=None, stride=None, pointer=
voidDataPointer(cls, value) method of _ctypes.PointerType instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object>
returnValues: <OpenGL.converters.returnPyArgument object>
Wrapping Operation: glColorPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glColorPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object>
cConverters: size=
arraySizeOfFirst(pyArgs, index, baseOperation)
Return the array size of the first argument
, type=GL_UNSIGNED_BYTE, stride=0, pointer=<OpenGL.converters.getPyArgsName object>
cResolvers: size=None, type=None, stride=None, pointer=
voidDataPointer(cls, value) method of _ctypes.PointerType instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object>
returnValues: <OpenGL.converters.returnPyArgument object>
Wrapping Operation: glColorPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glColorPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object>
cConverters: size=
arraySizeOfFirst(pyArgs, index, baseOperation)
Return the array size of the first argument
, type=GL_UNSIGNED_INT, stride=0, pointer=<OpenGL.converters.getPyArgsName object>
cResolvers: size=None, type=None, stride=None, pointer=
voidDataPointer(cls, value) method of _ctypes.PointerType instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object>
returnValues: <OpenGL.converters.returnPyArgument object>
Wrapping Operation: glColorPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glColorPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object>
cConverters: size=
arraySizeOfFirst(pyArgs, index, baseOperation)
Return the array size of the first argument
, type=GL_UNSIGNED_SHORT, stride=0, pointer=<OpenGL.converters.getPyArgsName object>
cResolvers: size=None, type=None, stride=None, pointer=
voidDataPointer(cls, value) method of _ctypes.PointerType instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object>
returnValues: <OpenGL.converters.returnPyArgument object>
Wrapping Operation: glColorPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glDrawElements( mode,count,type,indices )
pyConverters: mode=None, count=None, type=None, indices=<OpenGL.arrays.arrayhelpers.AsArrayOfType object>
cConverters: Not Used
cResolvers: mode=None, count=None, type=None, indices=
voidDataPointer(cls, value) method of type instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: Not Used
returnValues: <OpenGL.converters.returnPyArgument object>
Wrapping Operation: glDrawElements( GLenum(mode), GLsizei(count), GLenum(type), POINTER(GLvoid)(indices) ) -> None
glDrawElements( mode,indices )
pyConverters: mode=None, indices=<OpenGL.arrays.arrayhelpers.AsArrayTyped object>
cConverters: mode=None, count=<OpenGL.arrays.arrayhelpers.AsArrayTypedSize object>, type=GL_UNSIGNED_BYTE, indices=None
cResolvers: mode=None, count=None, type=None, indices=
voidDataPointer(cls, value) method of _ctypes.PointerType instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: Not Used
returnValues: <OpenGL.converters.returnPyArgument object>
Wrapping Operation: glDrawElements( GLenum(mode), GLsizei(count), GLenum(type), POINTER(GLvoid)(indices) ) -> None
glDrawElements( mode,indices )
pyConverters: mode=None, indices=<OpenGL.arrays.arrayhelpers.AsArrayTyped object>
cConverters: mode=None, count=<OpenGL.arrays.arrayhelpers.AsArrayTypedSize object>, type=GL_UNSIGNED_INT, indices=None
cResolvers: mode=None, count=None, type=None, indices=
voidDataPointer(cls, value) method of _ctypes.PointerType instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: Not Used
returnValues: <OpenGL.converters.returnPyArgument object>
Wrapping Operation: glDrawElements( GLenum(mode), GLsizei(count), GLenum(type), POINTER(GLvoid)(indices) ) -> None
glDrawElements( mode,indices )
pyConverters: mode=None, indices=<OpenGL.arrays.arrayhelpers.AsArrayTyped object>
cConverters: mode=None, count=<OpenGL.arrays.arrayhelpers.AsArrayTypedSize object>, type=GL_UNSIGNED_SHORT, indices=None
cResolvers: mode=None, count=None, type=None, indices=
voidDataPointer(cls, value) method of _ctypes.PointerType instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: Not Used
returnValues: <OpenGL.converters.returnPyArgument object>
Wrapping Operation: glDrawElements( GLenum(mode), GLsizei(count), GLenum(type), POINTER(GLvoid)(indices) ) -> None
glEdgeFlagPointer( stride,pointer )
pyConverters: stride=None, pointer=<OpenGL.arrays.arrayhelpers.AsArrayTyped object>
cConverters: Not Used
cResolvers: stride=None, pointer=
voidDataPointer(cls, value) method of type instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object>
returnValues: <OpenGL.converters.returnPyArgument object>
Wrapping Operation: glEdgeFlagPointer( GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glEdgeFlagPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object>
cConverters: stride=0, pointer=<OpenGL.converters.getPyArgsName object>
cResolvers: stride=None, pointer=
voidDataPointer(cls, value) method of _ctypes.PointerType instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object>
returnValues: <OpenGL.converters.returnPyArgument object>
Wrapping Operation: glEdgeFlagPointer( GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glFeedbackBuffer(size, type, buffer=None)
Create a selection buffer of the given size
glGetPointerv(constant)
Retrieve a stored pointer constant
glIndexPointer( type,stride,pointer )
pyConverters: type=None, stride=None, pointer=<OpenGL.arrays.arrayhelpers.AsArrayOfType object>
cConverters: Not Used
cResolvers: type=None, stride=None, pointer=
voidDataPointer(cls, value) method of type instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object>
returnValues: <OpenGL.converters.returnPyArgument object>
Wrapping Operation: glIndexPointer( GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glIndexPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object>
cConverters: type=GL_BYTE, stride=0, pointer=<OpenGL.converters.getPyArgsName object>
cResolvers: type=None, stride=None, pointer=
voidDataPointer(cls, value) method of _ctypes.PointerType instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object>
returnValues: <OpenGL.converters.returnPyArgument object>
Wrapping Operation: glIndexPointer( GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glIndexPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object>
cConverters: type=GL_DOUBLE, stride=0, pointer=<OpenGL.converters.getPyArgsName object>
cResolvers: type=None, stride=None, pointer=
voidDataPointer(cls, value) method of _ctypes.PointerType instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object>
returnValues: <OpenGL.converters.returnPyArgument object>
Wrapping Operation: glIndexPointer( GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glIndexPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object>
cConverters: type=GL_FLOAT, stride=0, pointer=<OpenGL.converters.getPyArgsName object>
cResolvers: type=None, stride=None, pointer=
voidDataPointer(cls, value) method of _ctypes.PointerType instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object>
returnValues: <OpenGL.converters.returnPyArgument object>
Wrapping Operation: glIndexPointer( GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glIndexPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object>
cConverters: type=GL_INT, stride=0, pointer=<OpenGL.converters.getPyArgsName object>
cResolvers: type=None, stride=None, pointer=
voidDataPointer(cls, value) method of _ctypes.PointerType instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object>
returnValues: <OpenGL.converters.returnPyArgument object>
Wrapping Operation: glIndexPointer( GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glIndexPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object>
cConverters: type=GL_SHORT, stride=0, pointer=<OpenGL.converters.getPyArgsName object>
cResolvers: type=None, stride=None, pointer=
voidDataPointer(cls, value) method of _ctypes.PointerType instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object>
returnValues: <OpenGL.converters.returnPyArgument object>
Wrapping Operation: glIndexPointer( GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glIndexPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object>
cConverters: type=GL_UNSIGNED_BYTE, stride=0, pointer=<OpenGL.converters.getPyArgsName object>
cResolvers: type=None, stride=None, pointer=
voidDataPointer(cls, value) method of _ctypes.PointerType instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object>
returnValues: <OpenGL.converters.returnPyArgument object>
Wrapping Operation: glIndexPointer( GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glInterleavedArrays = <OpenGL.wrapper.glInterleavedArrays object> glNormalPointer( type,stride,pointer )
pyConverters: type=None, stride=None, pointer=<OpenGL.arrays.arrayhelpers.AsArrayOfType object>
cConverters: Not Used
cResolvers: type=None, stride=None, pointer=
voidDataPointer(cls, value) method of type instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object>
returnValues: <OpenGL.converters.returnPyArgument object>
Wrapping Operation: glNormalPointer( GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glNormalPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object>
cConverters: type=GL_BYTE, stride=0, pointer=<OpenGL.converters.getPyArgsName object>
cResolvers: type=None, stride=None, pointer=
voidDataPointer(cls, value) method of _ctypes.PointerType instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object>
returnValues: <OpenGL.converters.returnPyArgument object>
Wrapping Operation: glNormalPointer( GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glNormalPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object>
cConverters: type=GL_DOUBLE, stride=0, pointer=<OpenGL.converters.getPyArgsName object>
cResolvers: type=None, stride=None, pointer=
voidDataPointer(cls, value) method of _ctypes.PointerType instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object>
returnValues: <OpenGL.converters.returnPyArgument object>
Wrapping Operation: glNormalPointer( GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glNormalPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object>
cConverters: type=GL_FLOAT, stride=0, pointer=<OpenGL.converters.getPyArgsName object>
cResolvers: type=None, stride=None, pointer=
voidDataPointer(cls, value) method of _ctypes.PointerType instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object>
returnValues: <OpenGL.converters.returnPyArgument object>
Wrapping Operation: glNormalPointer( GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glNormalPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object>
cConverters: type=GL_INT, stride=0, pointer=<OpenGL.converters.getPyArgsName object>
cResolvers: type=None, stride=None, pointer=
voidDataPointer(cls, value) method of _ctypes.PointerType instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object>
returnValues: <OpenGL.converters.returnPyArgument object>
Wrapping Operation: glNormalPointer( GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glNormalPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object>
cConverters: type=GL_SHORT, stride=0, pointer=<OpenGL.converters.getPyArgsName object>
cResolvers: type=None, stride=None, pointer=
voidDataPointer(cls, value) method of _ctypes.PointerType instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object>
returnValues: <OpenGL.converters.returnPyArgument object>
Wrapping Operation: glNormalPointer( GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glRenderMode(newMode)
Change to the given rendering mode
 
If the current mode is GL_FEEDBACK or GL_SELECT, return
the current buffer appropriate to the mode
glSelectBuffer(size, buffer=None)
Create a selection buffer of the given size
glTexCoordPointer( size,type,stride,pointer )
pyConverters: size=None, type=None, stride=None, pointer=<OpenGL.arrays.arrayhelpers.AsArrayOfType object>
cConverters: Not Used
cResolvers: size=None, type=None, stride=None, pointer=
voidDataPointer(cls, value) method of type instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object>
returnValues: <OpenGL.converters.returnPyArgument object>
Wrapping Operation: glTexCoordPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glTexCoordPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object>
cConverters: size=
arraySizeOfFirst(pyArgs, index, baseOperation)
Return the array size of the first argument
, type=GL_BYTE, stride=0, pointer=<OpenGL.converters.getPyArgsName object>
cResolvers: size=None, type=None, stride=None, pointer=
voidDataPointer(cls, value) method of _ctypes.PointerType instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object>
returnValues: <OpenGL.converters.returnPyArgument object>
Wrapping Operation: glTexCoordPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glTexCoordPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object>
cConverters: size=
arraySizeOfFirst(pyArgs, index, baseOperation)
Return the array size of the first argument
, type=GL_DOUBLE, stride=0, pointer=<OpenGL.converters.getPyArgsName object>
cResolvers: size=None, type=None, stride=None, pointer=
voidDataPointer(cls, value) method of _ctypes.PointerType instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object>
returnValues: <OpenGL.converters.returnPyArgument object>
Wrapping Operation: glTexCoordPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glTexCoordPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object>
cConverters: size=
arraySizeOfFirst(pyArgs, index, baseOperation)
Return the array size of the first argument
, type=GL_FLOAT, stride=0, pointer=<OpenGL.converters.getPyArgsName object>
cResolvers: size=None, type=None, stride=None, pointer=
voidDataPointer(cls, value) method of _ctypes.PointerType instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object>
returnValues: <OpenGL.converters.returnPyArgument object>
Wrapping Operation: glTexCoordPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glTexCoordPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object>
cConverters: size=
arraySizeOfFirst(pyArgs, index, baseOperation)
Return the array size of the first argument
, type=GL_INT, stride=0, pointer=<OpenGL.converters.getPyArgsName object>
cResolvers: size=None, type=None, stride=None, pointer=
voidDataPointer(cls, value) method of _ctypes.PointerType instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object>
returnValues: <OpenGL.converters.returnPyArgument object>
Wrapping Operation: glTexCoordPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glTexCoordPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object>
cConverters: size=
arraySizeOfFirst(pyArgs, index, baseOperation)
Return the array size of the first argument
, type=GL_SHORT, stride=0, pointer=<OpenGL.converters.getPyArgsName object>
cResolvers: size=None, type=None, stride=None, pointer=
voidDataPointer(cls, value) method of _ctypes.PointerType instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object>
returnValues: <OpenGL.converters.returnPyArgument object>
Wrapping Operation: glTexCoordPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glVertexPointer( size,type,stride,pointer )
pyConverters: size=None, type=None, stride=None, pointer=<OpenGL.arrays.arrayhelpers.AsArrayOfType object>
cConverters: Not Used
cResolvers: size=None, type=None, stride=None, pointer=
voidDataPointer(cls, value) method of type instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object>
returnValues: <OpenGL.converters.returnPyArgument object>
Wrapping Operation: glVertexPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glVertexPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object>
cConverters: size=
arraySizeOfFirst(pyArgs, index, baseOperation)
Return the array size of the first argument
, type=GL_INT, stride=0, pointer=<OpenGL.converters.getPyArgsName object>
cResolvers: size=None, type=None, stride=None, pointer=
voidDataPointer(cls, value) method of _ctypes.PointerType instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object>
returnValues: <OpenGL.converters.returnPyArgument object>
Wrapping Operation: glVertexPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glVertexPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object>
cConverters: size=
arraySizeOfFirst(pyArgs, index, baseOperation)
Return the array size of the first argument
, type=GL_DOUBLE, stride=0, pointer=<OpenGL.converters.getPyArgsName object>
cResolvers: size=None, type=None, stride=None, pointer=
voidDataPointer(cls, value) method of _ctypes.PointerType instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object>
returnValues: <OpenGL.converters.returnPyArgument object>
Wrapping Operation: glVertexPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glVertexPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object>
cConverters: size=
arraySizeOfFirst(pyArgs, index, baseOperation)
Return the array size of the first argument
, type=GL_FLOAT, stride=0, pointer=<OpenGL.converters.getPyArgsName object>
cResolvers: size=None, type=None, stride=None, pointer=
voidDataPointer(cls, value) method of _ctypes.PointerType instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object>
returnValues: <OpenGL.converters.returnPyArgument object>
Wrapping Operation: glVertexPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glVertexPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object>
cConverters: size=
arraySizeOfFirst(pyArgs, index, baseOperation)
Return the array size of the first argument
, type=GL_INT, stride=0, pointer=<OpenGL.converters.getPyArgsName object>
cResolvers: size=None, type=None, stride=None, pointer=
voidDataPointer(cls, value) method of _ctypes.PointerType instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object>
returnValues: <OpenGL.converters.returnPyArgument object>
Wrapping Operation: glVertexPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
glVertexPointer( pointer )
pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object>
cConverters: size=
arraySizeOfFirst(pyArgs, index, baseOperation)
Return the array size of the first argument
, type=GL_SHORT, stride=0, pointer=<OpenGL.converters.getPyArgsName object>
cResolvers: size=None, type=None, stride=None, pointer=
voidDataPointer(cls, value) method of _ctypes.PointerType instance
Given value in a known data-pointer type, return void_p for pointer
storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object>
returnValues: <OpenGL.converters.returnPyArgument object>
Wrapping Operation: glVertexPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
wrapPointerFunction(name, baseFunction, glType, arrayType, startArgs, defaultSize)
Wrap the given pointer-setting function

 
Data
        GL_INTERLEAVED_ARRAY_POINTER = GL_INTERLEAVED_ARRAY_POINTER
POINTER_FUNCTION_DATA = [('glColorPointerd', <CFunctionType object>, GL_DOUBLE, GL_COLOR_ARRAY_POINTER, 0, 3), ('glColorPointerf', <CFunctionType object>, GL_FLOAT, GL_COLOR_ARRAY_POINTER, 0, 3), ('glColorPointeri', <CFunctionType object>, GL_INT, GL_COLOR_ARRAY_POINTER, 0, 3), ('glColorPointers', <CFunctionType object>, GL_SHORT, GL_COLOR_ARRAY_POINTER, 0, 3), ('glColorPointerub', <CFunctionType object>, GL_UNSIGNED_BYTE, GL_COLOR_ARRAY_POINTER, 0, 3), ('glColorPointerb', <CFunctionType object>, GL_BYTE, GL_COLOR_ARRAY_POINTER, 0, 3), ('glColorPointerui', <CFunctionType object>, GL_UNSIGNED_INT, GL_COLOR_ARRAY_POINTER, 0, 3), ('glColorPointerus', <CFunctionType object>, GL_UNSIGNED_SHORT, GL_COLOR_ARRAY_POINTER, 0, 3), ('glEdgeFlagPointerb', <CFunctionType object>, GL_BYTE, GL_EDGE_FLAG_ARRAY_POINTER, 2, None), ('glIndexPointerd', <CFunctionType object>, GL_DOUBLE, GL_INDEX_ARRAY_POINTER, 1, None), ('glIndexPointerf', <CFunctionType object>, GL_FLOAT, GL_INDEX_ARRAY_POINTER, 1, None), ('glIndexPointeri', <CFunctionType object>, GL_INT, GL_INDEX_ARRAY_POINTER, 1, None), ('glIndexPointerub', <CFunctionType object>, GL_UNSIGNED_BYTE, GL_INDEX_ARRAY_POINTER, 1, None), ('glIndexPointers', <CFunctionType object>, GL_SHORT, GL_INDEX_ARRAY_POINTER, 1, None), ('glIndexPointerb', <CFunctionType object>, GL_BYTE, GL_INDEX_ARRAY_POINTER, 1, None), ('glNormalPointerd', <CFunctionType object>, GL_DOUBLE, GL_NORMAL_ARRAY_POINTER, 1, None), ('glNormalPointerf', <CFunctionType object>, GL_FLOAT, GL_NORMAL_ARRAY_POINTER, 1, None), ('glNormalPointeri', <CFunctionType object>, GL_INT, GL_NORMAL_ARRAY_POINTER, 1, None), ('glNormalPointerb', <CFunctionType object>, GL_BYTE, GL_NORMAL_ARRAY_POINTER, 1, None), ('glNormalPointers', <CFunctionType object>, GL_SHORT, GL_NORMAL_ARRAY_POINTER, 1, None), ...]
__all__ = ('glColorPointer', 'glColorPointerb', 'glColorPointerd', 'glColorPointerf', 'glColorPointeri', 'glColorPointers', 'glColorPointerub', 'glColorPointerui', 'glColorPointerus', 'glEdgeFlagPointer', 'glEdgeFlagPointerb', 'glIndexPointer', 'glIndexPointerb', 'glIndexPointerd', 'glIndexPointerf', 'glIndexPointeri', 'glIndexPointers', 'glIndexPointerub', 'glNormalPointer', 'glNormalPointerb', ...)
args = ('glVertexPointers', <CFunctionType object>, GL_SHORT, GL_VERTEX_ARRAY_POINTER, 0, 3)