OpenGL.GL.images
index
/build/buildd/pyopengl-3.0.0~b6/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 0x87a6eac>
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 0x829e3ac>
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 0x829e44c>
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 0x87b070c>
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 0x87b018c>
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 0x879052c>
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 0x879036c>
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 0x878656c>
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, outputType=<type 'str'>)
Get a texture-level as an image
 
target -- enum constant for the texture engine to be read 
level -- the mip-map level to read 
format -- image format to read out the data 
type -- data-type into which to read the data
 
outputType -- default (str) provides string output of the 
        results iff OpenGL.UNSIGNED_BYTE_IMAGES_AS_STRING is True 
        and type == GL_UNSIGNED_BYTE.  Any other value will cause 
        output in the default array output format.
 
returns the pixel data array in the format defined by the 
format, type and outputType
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, outputType=<type 'str'>)
Read specified pixels from the current display buffer
 
x,y,width,height -- location and dimensions of the image to read 
        from the buffer
format -- pixel format for the resulting data
type -- data-format for the resulting data
outputType -- default (str) provides string output of the 
        results iff OpenGL.UNSIGNED_BYTE_IMAGES_AS_STRING is True 
        and type == GL_UNSIGNED_BYTE.  Any other value will cause 
        output in the default array output format.
 
returns the pixel data array in the format defined by the 
format, type and outputType
glReadPixelsb = glReadPixels(x, y, width, height, format, type=GL_BYTE)
Read specified pixels from the current display buffer
 
This typed version returns data in your specified default 
array data-type format
glReadPixelsd = glReadPixels(x, y, width, height, format, type=GL_DOUBLE)
Read specified pixels from the current display buffer
 
This typed version returns data in your specified default 
array data-type format
glReadPixelsf = glReadPixels(x, y, width, height, format, type=GL_FLOAT)
Read specified pixels from the current display buffer
 
This typed version returns data in your specified default 
array data-type format
glReadPixelsi = glReadPixels(x, y, width, height, format, type=GL_INT)
Read specified pixels from the current display buffer
 
This typed version returns data in your specified default 
array data-type format
glReadPixelss = glReadPixels(x, y, width, height, format, type=GL_SHORT)
Read specified pixels from the current display buffer
 
This typed version returns data in your specified default 
array data-type format
glReadPixelsub = glReadPixels(x, y, width, height, format, type=GL_UNSIGNED_BYTE)
Read specified pixels from the current display buffer
 
This typed version returns data in your specified default 
array data-type format
glReadPixelsui = glReadPixels(x, y, width, height, format, type=GL_UNSIGNED_INT)
Read specified pixels from the current display buffer
 
This typed version returns data in your specified default 
array data-type format
glReadPixelsus = glReadPixels(x, y, width, height, format, type=GL_UNSIGNED_SHORT)
Read specified pixels from the current display buffer
 
This typed version returns data in your specified default 
array data-type format
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 0x829e52c>
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 0x829eaec>
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 0x829e82c>
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 0x829efcc>
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 0x87b050c>
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 0x87902ec>
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 0x879090c>
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 0x8790d0c>
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 0x829eb8c>
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 0x829e90c>
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 0x829e1ec>
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 0x829eb0c>
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 0x87b02ec>
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 0x879046c>
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 0x87901ec>
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 0x8786b2c>
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 0x829e74c>
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 0x829efec>
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 0x829e98c>
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 0x87b04cc>
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 0x87b008c>
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 0x87907cc>
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 0x8790d8c>
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 0x8786f0c>
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 0x829e42c>
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 0x829eecc>
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 0x829eb2c>
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 0x87b080c>
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 0x87b084c>
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 0x8790b4c>
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 0x879062c>
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 0x8786b0c>
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', ...)
__file__ = '/build/buildd/pyopengl-3.0.0~b6/OpenGL/GL/images.py'
__name__ = 'OpenGL.GL.images'