OpenGL.GL.images
index
/var/pylive/src/OpenGL-dev/OpenGL-ctypes/OpenGL/GL/images.py

Image-handling routines
 
### Unresolved:
 
        Following methods are not yet resolved due to my not being sure how the 
        function should be wrapped:
        
                glCompressedTexImage3D
                glCompressedTexImage2D
                glCompressedTexImage1D
                glCompressedTexSubImage3D
                glCompressedTexSubImage2D
                glCompressedTexSubImage1D

 
Modules
       
OpenGL.arrays
ctypes
OpenGL.images
OpenGL.platform
OpenGL.raw.GL
OpenGL.wrapper

 
Classes
       
object
CompressedImageConverter
ImageInputConverter
TypedImageInputConverter

 
class CompressedImageConverter(object)
     Methods defined here:
__call__(self, pyArgs, index, wrappedOperation)
Create a data-size measurement for our image
finalise(self, wrapper)
Get our pixel index from the wrapper

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

 
class ImageInputConverter(object)
     Methods defined here:
__call__(self, arg, baseOperation, pyArgs)
pyConverter for the pixels argument
__init__(self, rank, pixelsName=None, typeName='type')
cResolver(self, array)
finalise(self, wrapper)
Get our pixel index from the wrapper

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

 
class TypedImageInputConverter(ImageInputConverter)
    
Method resolution order:
TypedImageInputConverter
ImageInputConverter
object

Methods defined here:
__call__(self, arg, baseOperation, pyArgs)
The pyConverter for the pixels
__init__(self, rank, pixelsName, arrayType, typeName=None)
depth(self, pyArgs, index, wrappedOperation)
Extract the depth from the pixels argument
finalise(self, wrapper)
Get our pixel index from the wrapper
height(self, pyArgs, index, wrappedOperation)
Extract the height from the pixels argument
type(self, pyArgs, index, wrappedOperation)
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
width(self, pyArgs, index, wrappedOperation)
Extract the width from the pixels argument

Methods inherited from ImageInputConverter:
cResolver(self, array)

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

 
Functions
       
_setDataSize(baseFunction, argument='imageSize')
Set the data-size value to come from the data field
asInt(value)
asIntConverter(value, *args)
asWrapper(value)
compressedImageFunction(baseFunction)
Set the imageSize and dimensions-as-ints converters for baseFunction
glDrawPixels( width,height,format,type,pixels )
pyConverters: width=
asIntConverter(value, *args)
, height=
asIntConverter(value, *args)
, format=None, type=None, pixels=<OpenGL.GL.images.ImageInputConverter object at 0x2aaab292ae90>
cConverters: Not Used
cResolvers: width=None, height=None, format=None, type=None, pixels=
cResolver(self, array) method of ImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glDrawPixels( GLsizei(width), GLsizei(height), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glDrawPixels( format,pixels )
pyConverters: format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab2935650>
cConverters: width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, height=
height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the height from the pixels argument
, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: width=None, height=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glDrawPixels( GLsizei(width), GLsizei(height), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glDrawPixels( format,pixels )
pyConverters: format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab2935a10>
cConverters: width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, height=
height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the height from the pixels argument
, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: width=None, height=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glDrawPixels( GLsizei(width), GLsizei(height), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glDrawPixels( format,pixels )
pyConverters: format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab2935dd0>
cConverters: width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, height=
height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the height from the pixels argument
, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: width=None, height=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glDrawPixels( GLsizei(width), GLsizei(height), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glDrawPixels( format,pixels )
pyConverters: format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab293b1d0>
cConverters: width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, height=
height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the height from the pixels argument
, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: width=None, height=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glDrawPixels( GLsizei(width), GLsizei(height), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glDrawPixels( format,pixels )
pyConverters: format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab293b610>
cConverters: width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, height=
height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the height from the pixels argument
, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: width=None, height=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glDrawPixels( GLsizei(width), GLsizei(height), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glDrawPixels( format,pixels )
pyConverters: format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab293ba50>
cConverters: width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, height=
height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the height from the pixels argument
, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: width=None, height=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glDrawPixels( GLsizei(width), GLsizei(height), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glDrawPixels( format,pixels )
pyConverters: format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab293be90>
cConverters: width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, height=
height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the height from the pixels argument
, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: width=None, height=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glDrawPixels( GLsizei(width), GLsizei(height), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glGetTexImage(target, level, format, type)
Get a texture-level as an image
glGetTexImageb = glGetTexImage(target, level, format, type=GL_BYTE)
Get a texture-level as an image
glGetTexImaged = glGetTexImage(target, level, format, type=GL_DOUBLE)
Get a texture-level as an image
glGetTexImagef = glGetTexImage(target, level, format, type=GL_FLOAT)
Get a texture-level as an image
glGetTexImagei = glGetTexImage(target, level, format, type=GL_INT)
Get a texture-level as an image
glGetTexImages = glGetTexImage(target, level, format, type=GL_SHORT)
Get a texture-level as an image
glGetTexImageub = glGetTexImage(target, level, format, type=GL_UNSIGNED_BYTE)
Get a texture-level as an image
glGetTexImageui = glGetTexImage(target, level, format, type=GL_UNSIGNED_INT)
Get a texture-level as an image
glGetTexImageus = glGetTexImage(target, level, format, type=GL_UNSIGNED_SHORT)
Get a texture-level as an image
glReadPixels(x, y, width, height, format, type)
Read specified pixels from the current display buffer
glReadPixelsb = glReadPixels(x, y, width, height, format, type=GL_BYTE)
Read specified pixels from the current display buffer
glReadPixelsd = glReadPixels(x, y, width, height, format, type=GL_DOUBLE)
Read specified pixels from the current display buffer
glReadPixelsf = glReadPixels(x, y, width, height, format, type=GL_FLOAT)
Read specified pixels from the current display buffer
glReadPixelsi = glReadPixels(x, y, width, height, format, type=GL_INT)
Read specified pixels from the current display buffer
glReadPixelss = glReadPixels(x, y, width, height, format, type=GL_SHORT)
Read specified pixels from the current display buffer
glReadPixelsub = glReadPixels(x, y, width, height, format, type=GL_UNSIGNED_BYTE)
Read specified pixels from the current display buffer
glReadPixelsui = glReadPixels(x, y, width, height, format, type=GL_UNSIGNED_INT)
Read specified pixels from the current display buffer
glReadPixelsus = glReadPixels(x, y, width, height, format, type=GL_UNSIGNED_SHORT)
Read specified pixels from the current display buffer
glTexImage1D( target,level,internalformat,width,border,format,type,pixels )
pyConverters: target=None, level=None, internalformat=None, width=
asIntConverter(value, *args)
, border=None, format=None, type=None, pixels=<OpenGL.GL.images.ImageInputConverter object at 0x2aaab29351d0>
cConverters: Not Used
cResolvers: target=None, level=None, internalformat=None, width=None, border=None, format=None, type=None, pixels=
cResolver(self, array) method of ImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexImage1D( GLenum(target), GLint(level), GLint(internalformat), GLsizei(width), GLint(border), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glTexImage1D( target,level,internalformat,border,format,pixels )
pyConverters: target=None, level=None, internalformat=None, border=None, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab2935350>
cConverters: target=None, level=None, internalformat=None, width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, border=None, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: target=None, level=None, internalformat=None, width=None, border=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexImage1D( GLenum(target), GLint(level), GLint(internalformat), GLsizei(width), GLint(border), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glTexImage1D( target,level,internalformat,border,format,pixels )
pyConverters: target=None, level=None, internalformat=None, border=None, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab2935710>
cConverters: target=None, level=None, internalformat=None, width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, border=None, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: target=None, level=None, internalformat=None, width=None, border=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexImage1D( GLenum(target), GLint(level), GLint(internalformat), GLsizei(width), GLint(border), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glTexImage1D( target,level,internalformat,border,format,pixels )
pyConverters: target=None, level=None, internalformat=None, border=None, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab2935ad0>
cConverters: target=None, level=None, internalformat=None, width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, border=None, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: target=None, level=None, internalformat=None, width=None, border=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexImage1D( GLenum(target), GLint(level), GLint(internalformat), GLsizei(width), GLint(border), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glTexImage1D( target,level,internalformat,border,format,pixels )
pyConverters: target=None, level=None, internalformat=None, border=None, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab2935e90>
cConverters: target=None, level=None, internalformat=None, width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, border=None, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: target=None, level=None, internalformat=None, width=None, border=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexImage1D( GLenum(target), GLint(level), GLint(internalformat), GLsizei(width), GLint(border), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glTexImage1D( target,level,internalformat,border,format,pixels )
pyConverters: target=None, level=None, internalformat=None, border=None, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab293b290>
cConverters: target=None, level=None, internalformat=None, width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, border=None, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: target=None, level=None, internalformat=None, width=None, border=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexImage1D( GLenum(target), GLint(level), GLint(internalformat), GLsizei(width), GLint(border), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glTexImage1D( target,level,internalformat,border,format,pixels )
pyConverters: target=None, level=None, internalformat=None, border=None, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab293b6d0>
cConverters: target=None, level=None, internalformat=None, width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, border=None, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: target=None, level=None, internalformat=None, width=None, border=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexImage1D( GLenum(target), GLint(level), GLint(internalformat), GLsizei(width), GLint(border), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glTexImage1D( target,level,internalformat,border,format,pixels )
pyConverters: target=None, level=None, internalformat=None, border=None, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab293bb10>
cConverters: target=None, level=None, internalformat=None, width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, border=None, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: target=None, level=None, internalformat=None, width=None, border=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexImage1D( GLenum(target), GLint(level), GLint(internalformat), GLsizei(width), GLint(border), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glTexImage2D( target,level,internalformat,width,height,border,format,type,pixels )
pyConverters: target=None, level=None, internalformat=None, width=
asIntConverter(value, *args)
, height=
asIntConverter(value, *args)
, border=None, format=None, type=None, pixels=<OpenGL.GL.images.ImageInputConverter object at 0x2aaab2935110>
cConverters: Not Used
cResolvers: target=None, level=None, internalformat=None, width=None, height=None, border=None, format=None, type=None, pixels=
cResolver(self, array) method of ImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexImage2D( GLenum(target), GLint(level), GLint(internalformat), GLsizei(width), GLsizei(height), GLint(border), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glTexImage2D( target,level,internalformat,border,format,pixels )
pyConverters: target=None, level=None, internalformat=None, border=None, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab2935410>
cConverters: target=None, level=None, internalformat=None, width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, height=
height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the height from the pixels argument
, border=None, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: target=None, level=None, internalformat=None, width=None, height=None, border=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexImage2D( GLenum(target), GLint(level), GLint(internalformat), GLsizei(width), GLsizei(height), GLint(border), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glTexImage2D( target,level,internalformat,border,format,pixels )
pyConverters: target=None, level=None, internalformat=None, border=None, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab29357d0>
cConverters: target=None, level=None, internalformat=None, width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, height=
height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the height from the pixels argument
, border=None, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: target=None, level=None, internalformat=None, width=None, height=None, border=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexImage2D( GLenum(target), GLint(level), GLint(internalformat), GLsizei(width), GLsizei(height), GLint(border), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glTexImage2D( target,level,internalformat,border,format,pixels )
pyConverters: target=None, level=None, internalformat=None, border=None, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab2935b90>
cConverters: target=None, level=None, internalformat=None, width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, height=
height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the height from the pixels argument
, border=None, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: target=None, level=None, internalformat=None, width=None, height=None, border=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexImage2D( GLenum(target), GLint(level), GLint(internalformat), GLsizei(width), GLsizei(height), GLint(border), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glTexImage2D( target,level,internalformat,border,format,pixels )
pyConverters: target=None, level=None, internalformat=None, border=None, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab2935f50>
cConverters: target=None, level=None, internalformat=None, width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, height=
height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the height from the pixels argument
, border=None, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: target=None, level=None, internalformat=None, width=None, height=None, border=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexImage2D( GLenum(target), GLint(level), GLint(internalformat), GLsizei(width), GLsizei(height), GLint(border), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glTexImage2D( target,level,internalformat,border,format,pixels )
pyConverters: target=None, level=None, internalformat=None, border=None, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab293b350>
cConverters: target=None, level=None, internalformat=None, width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, height=
height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the height from the pixels argument
, border=None, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: target=None, level=None, internalformat=None, width=None, height=None, border=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexImage2D( GLenum(target), GLint(level), GLint(internalformat), GLsizei(width), GLsizei(height), GLint(border), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glTexImage2D( target,level,internalformat,border,format,pixels )
pyConverters: target=None, level=None, internalformat=None, border=None, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab293b790>
cConverters: target=None, level=None, internalformat=None, width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, height=
height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the height from the pixels argument
, border=None, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: target=None, level=None, internalformat=None, width=None, height=None, border=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexImage2D( GLenum(target), GLint(level), GLint(internalformat), GLsizei(width), GLsizei(height), GLint(border), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glTexImage2D( target,level,internalformat,border,format,pixels )
pyConverters: target=None, level=None, internalformat=None, border=None, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab293bbd0>
cConverters: target=None, level=None, internalformat=None, width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, height=
height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the height from the pixels argument
, border=None, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: target=None, level=None, internalformat=None, width=None, height=None, border=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexImage2D( GLenum(target), GLint(level), GLint(internalformat), GLsizei(width), GLsizei(height), GLint(border), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glTexSubImage1D( target,level,xoffset,width,format,type,pixels )
pyConverters: target=None, level=None, xoffset=
asIntConverter(value, *args)
, width=
asIntConverter(value, *args)
, format=None, type=None, pixels=<OpenGL.GL.images.ImageInputConverter object at 0x2aaab2935050>
cConverters: Not Used
cResolvers: target=None, level=None, xoffset=None, width=None, format=None, type=None, pixels=
cResolver(self, array) method of ImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexSubImage1D( GLenum(target), GLint(level), GLint(xoffset), GLsizei(width), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glTexSubImage1D( target,level,xoffset,format,pixels )
pyConverters: target=None, level=None, xoffset=
asIntConverter(value, *args)
, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab29354d0>
cConverters: target=None, level=None, xoffset=None, width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: target=None, level=None, xoffset=None, width=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexSubImage1D( GLenum(target), GLint(level), GLint(xoffset), GLsizei(width), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glTexSubImage1D( target,level,xoffset,format,pixels )
pyConverters: target=None, level=None, xoffset=
asIntConverter(value, *args)
, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab2935890>
cConverters: target=None, level=None, xoffset=None, width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: target=None, level=None, xoffset=None, width=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexSubImage1D( GLenum(target), GLint(level), GLint(xoffset), GLsizei(width), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glTexSubImage1D( target,level,xoffset,format,pixels )
pyConverters: target=None, level=None, xoffset=
asIntConverter(value, *args)
, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab2935c50>
cConverters: target=None, level=None, xoffset=None, width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: target=None, level=None, xoffset=None, width=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexSubImage1D( GLenum(target), GLint(level), GLint(xoffset), GLsizei(width), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glTexSubImage1D( target,level,xoffset,format,pixels )
pyConverters: target=None, level=None, xoffset=
asIntConverter(value, *args)
, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab293b050>
cConverters: target=None, level=None, xoffset=None, width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: target=None, level=None, xoffset=None, width=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexSubImage1D( GLenum(target), GLint(level), GLint(xoffset), GLsizei(width), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glTexSubImage1D( target,level,xoffset,format,pixels )
pyConverters: target=None, level=None, xoffset=
asIntConverter(value, *args)
, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab293b410>
cConverters: target=None, level=None, xoffset=None, width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: target=None, level=None, xoffset=None, width=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexSubImage1D( GLenum(target), GLint(level), GLint(xoffset), GLsizei(width), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glTexSubImage1D( target,level,xoffset,format,pixels )
pyConverters: target=None, level=None, xoffset=
asIntConverter(value, *args)
, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab293b850>
cConverters: target=None, level=None, xoffset=None, width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: target=None, level=None, xoffset=None, width=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexSubImage1D( GLenum(target), GLint(level), GLint(xoffset), GLsizei(width), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glTexSubImage1D( target,level,xoffset,format,pixels )
pyConverters: target=None, level=None, xoffset=
asIntConverter(value, *args)
, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab293bc90>
cConverters: target=None, level=None, xoffset=None, width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: target=None, level=None, xoffset=None, width=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexSubImage1D( GLenum(target), GLint(level), GLint(xoffset), GLsizei(width), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glTexSubImage2D( target,level,xoffset,yoffset,width,height,format,type,pixels )
pyConverters: target=None, level=None, xoffset=
asIntConverter(value, *args)
, yoffset=
asIntConverter(value, *args)
, width=
asIntConverter(value, *args)
, height=
asIntConverter(value, *args)
, format=None, type=None, pixels=<OpenGL.GL.images.ImageInputConverter object at 0x2aaab292af50>
cConverters: Not Used
cResolvers: target=None, level=None, xoffset=None, yoffset=None, width=None, height=None, format=None, type=None, pixels=
cResolver(self, array) method of ImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexSubImage2D( GLenum(target), GLint(level), GLint(xoffset), GLint(yoffset), GLsizei(width), GLsizei(height), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glTexSubImage2D( target,level,xoffset,yoffset,format,pixels )
pyConverters: target=None, level=None, xoffset=
asIntConverter(value, *args)
, yoffset=
asIntConverter(value, *args)
, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab2935590>
cConverters: target=None, level=None, xoffset=None, yoffset=None, width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, height=
height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the height from the pixels argument
, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: target=None, level=None, xoffset=None, yoffset=None, width=None, height=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexSubImage2D( GLenum(target), GLint(level), GLint(xoffset), GLint(yoffset), GLsizei(width), GLsizei(height), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glTexSubImage2D( target,level,xoffset,yoffset,format,pixels )
pyConverters: target=None, level=None, xoffset=
asIntConverter(value, *args)
, yoffset=
asIntConverter(value, *args)
, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab2935950>
cConverters: target=None, level=None, xoffset=None, yoffset=None, width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, height=
height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the height from the pixels argument
, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: target=None, level=None, xoffset=None, yoffset=None, width=None, height=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexSubImage2D( GLenum(target), GLint(level), GLint(xoffset), GLint(yoffset), GLsizei(width), GLsizei(height), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glTexSubImage2D( target,level,xoffset,yoffset,format,pixels )
pyConverters: target=None, level=None, xoffset=
asIntConverter(value, *args)
, yoffset=
asIntConverter(value, *args)
, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab2935d10>
cConverters: target=None, level=None, xoffset=None, yoffset=None, width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, height=
height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the height from the pixels argument
, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: target=None, level=None, xoffset=None, yoffset=None, width=None, height=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexSubImage2D( GLenum(target), GLint(level), GLint(xoffset), GLint(yoffset), GLsizei(width), GLsizei(height), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glTexSubImage2D( target,level,xoffset,yoffset,format,pixels )
pyConverters: target=None, level=None, xoffset=
asIntConverter(value, *args)
, yoffset=
asIntConverter(value, *args)
, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab293b110>
cConverters: target=None, level=None, xoffset=None, yoffset=None, width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, height=
height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the height from the pixels argument
, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: target=None, level=None, xoffset=None, yoffset=None, width=None, height=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexSubImage2D( GLenum(target), GLint(level), GLint(xoffset), GLint(yoffset), GLsizei(width), GLsizei(height), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glTexSubImage2D( target,level,xoffset,yoffset,format,pixels )
pyConverters: target=None, level=None, xoffset=
asIntConverter(value, *args)
, yoffset=
asIntConverter(value, *args)
, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab293b510>
cConverters: target=None, level=None, xoffset=None, yoffset=None, width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, height=
height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the height from the pixels argument
, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: target=None, level=None, xoffset=None, yoffset=None, width=None, height=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexSubImage2D( GLenum(target), GLint(level), GLint(xoffset), GLint(yoffset), GLsizei(width), GLsizei(height), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glTexSubImage2D( target,level,xoffset,yoffset,format,pixels )
pyConverters: target=None, level=None, xoffset=
asIntConverter(value, *args)
, yoffset=
asIntConverter(value, *args)
, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab293b950>
cConverters: target=None, level=None, xoffset=None, yoffset=None, width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, height=
height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the height from the pixels argument
, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: target=None, level=None, xoffset=None, yoffset=None, width=None, height=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexSubImage2D( GLenum(target), GLint(level), GLint(xoffset), GLint(yoffset), GLsizei(width), GLsizei(height), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
glTexSubImage2D( target,level,xoffset,yoffset,format,pixels )
pyConverters: target=None, level=None, xoffset=
asIntConverter(value, *args)
, yoffset=
asIntConverter(value, *args)
, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab293bd90>
cConverters: target=None, level=None, xoffset=None, yoffset=None, width=
width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the width from the pixels argument
, height=
height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the height from the pixels argument
, format=None, type=
type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Provide the item-type argument from our stored value
 
This is used for pre-bound processing where we want to provide 
the type by implication...
, pixels=None
cResolvers: target=None, level=None, xoffset=None, yoffset=None, width=None, height=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexSubImage2D( GLenum(target), GLint(level), GLint(xoffset), GLint(yoffset), GLsizei(width), GLsizei(height), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
setDimensionsAsInts(baseOperation)
Set arguments with names in INT_DIMENSION_NAMES to asInt processing
setImageInput(baseOperation, arrayType=None, dimNames=('width', 'height', 'depth'), pixelName='pixels', typeName=None)
Determine how to convert "pixels" into an image-compatible argument
typedImageFunction(suffix, arrayConstant, baseFunction)
Produce a typed version of the given image function

 
Data
        DATA_SIZE_NAMES = ('imageSize',)
DIMENSION_NAMES = ('width', 'height', 'depth')
INT_DIMENSION_NAMES = ['width', 'height', 'depth', 'x', 'y', 'z', 'xoffset', 'yoffset', 'zoffset', 'start', 'count']
PIXEL_NAMES = ('pixels', 'row', 'column')
__all__ = ('glReadPixels', 'glReadPixelsb', 'glReadPixelsd', 'glReadPixelsf', 'glReadPixelsi', 'glReadPixelss', 'glReadPixelsub', 'glReadPixelsui', 'glReadPixelsus', 'glGetTexImage', 'glDrawPixels', 'glDrawPixelsb', 'glDrawPixelsf', 'glDrawPixelsi', 'glDrawPixelss', 'glDrawPixelsub', 'glDrawPixelsui', 'glDrawPixelsus', 'glTexSubImage2D', 'glTexSubImage1D', ...)