OpenGL.GL.VERSION.GL_1_2_images
index
/build/buildd/pyopengl-3.0.0~b3/OpenGL/GL/VERSION/GL_1_2_images.py

Version 1.2 Image-handling functions
 
Almost all of the 1.2 enhancements are image-handling-related,
so this is, most of the 1.2 wrapper code...
 
Note that the functions that manually wrap certain operations are
guarded by if simple.functionName checks, so that you can use
if functionName to see if the function is available at run-time.

 
Modules
       
OpenGL.arrays
OpenGL.constants
ctypes
OpenGL.GL.images
OpenGL.raw.GL.ARB.imaging
OpenGL.raw.GL.VERSION.GL_1_2
OpenGL.wrapper

 
Functions
        glColorSubTable( target,start,count,format,type,data )
pyConverters: target=None, start=
asIntConverter(value, *args)
, count=
asIntConverter(value, *args)
, format=None, type=None, data=<OpenGL.GL.images.ImageInputConverter object at 0x827ffac>
cConverters: Not Used
cResolvers: target=None, start=None, count=None, format=None, type=None, data=
cResolver(self, array) method of ImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glColorSubTable( GLenum(target), GLsizei(start), GLsizei(count), GLenum(format), GLenum(type), c_void_p(data) ) -> None
glColorTable( target,internalformat,width,format,type,table )
pyConverters: target=None, internalformat=None, width=
asIntConverter(value, *args)
, format=None, type=None, table=<OpenGL.GL.images.ImageInputConverter object at 0x827fd2c>
cConverters: Not Used
cResolvers: target=None, internalformat=None, width=None, format=None, type=None, table=
cResolver(self, array) method of ImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glColorTable( GLenum(target), GLenum(internalformat), GLsizei(width), GLenum(format), GLenum(type), c_void_p(table) ) -> None
glColorTableParameterfv( target,pname,params )
pyConverters: target=None, pname=None, params=
asArraySize(incoming, function, args)
cConverters: target=None, pname=None, params=<OpenGL.converters.getPyArgsName object at 0x879f34c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
returnPointer(result, baseOperation, pyArgs, cArgs)
Return the converted object as result of function
 
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glColorTableParameterfv( GLenum(target), GLenum(pname), GLfloatArray(params) ) -> None
glConvolutionFilter1D( target,internalformat,width,format,type,image )
pyConverters: target=None, internalformat=None, width=
asIntConverter(value, *args)
, format=None, type=None, image=<OpenGL.GL.images.ImageInputConverter object at 0x827f76c>
cConverters: Not Used
cResolvers: target=None, internalformat=None, width=None, format=None, type=None, image=
cResolver(self, array) method of ImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glConvolutionFilter1D( GLenum(target), GLenum(internalformat), GLsizei(width), GLenum(format), GLenum(type), c_void_p(image) ) -> None
glConvolutionFilter2D( target,internalformat,width,height,format,type,image )
pyConverters: target=None, internalformat=None, width=
asIntConverter(value, *args)
, height=
asIntConverter(value, *args)
, format=None, type=None, image=<OpenGL.GL.images.ImageInputConverter object at 0x827f32c>
cConverters: Not Used
cResolvers: target=None, internalformat=None, width=None, height=None, format=None, type=None, image=
cResolver(self, array) method of ImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glConvolutionFilter2D( GLenum(target), GLenum(internalformat), GLsizei(width), GLsizei(height), GLenum(format), GLenum(type), c_void_p(image) ) -> None
glGetColorTable(target, format, type)
Retrieve the current 1D color table as a bitmap
glGetColorTableParameterfv( target,pname )
pyConverters: target=None, pname=None
cConverters: target=None, pname=None, params=<OpenGL.converters.SizedOutput object at 0x856409c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
oldStyleReturn(self, result, baseOperation, pyArgs, cArgs) method of SizedOutput instance
Retrieve cArgs[ self.index ]
Wrapping Operation: glGetColorTableParameterfv( GLenum(target), GLenum(pname), GLfloatArray(params) ) -> None
glGetColorTableParameteriv( target,pname )
pyConverters: target=None, pname=None
cConverters: target=None, pname=None, params=<OpenGL.converters.SizedOutput object at 0x856410c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
oldStyleReturn(self, result, baseOperation, pyArgs, cArgs) method of SizedOutput instance
Retrieve cArgs[ self.index ]
Wrapping Operation: glGetColorTableParameteriv( GLenum(target), GLenum(pname), GLintArray(params) ) -> None
glGetConvolutionFilter(target, format, type)
Retrieve 1 or 2D convolution parameter "kernels" as pixel data
glGetConvolutionParameterfv( target,pname )
pyConverters: target=None, pname=None
cConverters: target=None, pname=None, params=<OpenGL.converters.SizedOutput object at 0x85641ec>
cResolvers: Not Used
storeValues: Not Used
returnValues:
oldStyleReturn(self, result, baseOperation, pyArgs, cArgs) method of SizedOutput instance
Retrieve cArgs[ self.index ]
Wrapping Operation: glGetConvolutionParameterfv( GLenum(target), GLenum(pname), GLfloatArray(params) ) -> None
glGetConvolutionParameteriv( target,pname )
pyConverters: target=None, pname=None
cConverters: target=None, pname=None, params=<OpenGL.converters.SizedOutput object at 0x856417c>
cResolvers: Not Used
storeValues: Not Used
returnValues:
oldStyleReturn(self, result, baseOperation, pyArgs, cArgs) method of SizedOutput instance
Retrieve cArgs[ self.index ]
Wrapping Operation: glGetConvolutionParameteriv( GLenum(target), GLenum(pname), GLintArray(params) ) -> None
glGetHistogram(target, reset, format, type, values=None)
Retrieve current 1D histogram as a 1D bitmap
glGetHistogramParameterfv( target,pname )
pyConverters: target=None, pname=None
cConverters: target=None, pname=None, params=<OpenGL.converters.Output object at 0x8b7a0cc>
cResolvers: Not Used
storeValues: Not Used
returnValues:
oldStyleReturn(self, result, baseOperation, pyArgs, cArgs) method of Output instance
Retrieve cArgs[ self.index ]
Wrapping Operation: glGetHistogramParameterfv( GLenum(target), GLenum(pname), GLfloatArray(params) ) -> None
glGetHistogramParameteriv( target,pname )
pyConverters: target=None, pname=None
cConverters: target=None, pname=None, params=<OpenGL.converters.Output object at 0x8b7a144>
cResolvers: Not Used
storeValues: Not Used
returnValues:
oldStyleReturn(self, result, baseOperation, pyArgs, cArgs) method of Output instance
Retrieve cArgs[ self.index ]
Wrapping Operation: glGetHistogramParameteriv( GLenum(target), GLenum(pname), GLintArray(params) ) -> None
glGetMinmax(target, reset, format, type, values=None)
Retrieve minimum and maximum values as a 2-element image
glGetSeparableFilter(target, format, type)
Retrieve 2 1D convolution parameter "kernels" as pixel data
glSeparableFilter2D( target,internalformat,width,height,format,type,row,column )
pyConverters: target=None, internalformat=None, width=
asIntConverter(value, *args)
, height=
asIntConverter(value, *args)
, format=None, type=None, row=<OpenGL.GL.images.ImageInputConverter object at 0x827fe6c>, column=<OpenGL.GL.images.ImageInputConverter object at 0x827ff8c>
cConverters: Not Used
cResolvers: target=None, internalformat=None, width=None, height=None, format=None, type=None, row=
cResolver(self, array) method of ImageInputConverter instance
, column=
cResolver(self, array) method of ImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glSeparableFilter2D( GLenum(target), GLenum(internalformat), GLsizei(width), GLsizei(height), GLenum(format), GLenum(type), c_void_p(row), c_void_p(column) ) -> None
glTexImage3D( target,level,internalformat,width,height,depth,border,format,type,pixels )
pyConverters: target=None, level=None, internalformat=None, width=
asIntConverter(value, *args)
, height=
asIntConverter(value, *args)
, depth=
asIntConverter(value, *args)
, border=None, format=None, type=None, pixels=<OpenGL.GL.images.ImageInputConverter object at 0x827ff6c>
cConverters: Not Used
cResolvers: target=None, level=None, internalformat=None, width=None, height=None, depth=None, border=None, format=None, type=None, pixels=
cResolver(self, array) method of ImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexImage3D( GLenum(target), GLint(level), GLint(internalformat), GLsizei(width), GLsizei(height), GLsizei(depth), GLint(border), GLenum(format), GLenum(type), c_void_p(pixels) ) -> None
glTexImage3D( target,level,internalformat,border,format,pixels )
pyConverters: target=None, level=None, internalformat=None, border=None, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x87be9cc>
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
, depth=
depth(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the depth 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, depth=None, border=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexImage3D( GLenum(target), GLint(level), GLint(internalformat), GLsizei(width), GLsizei(height), GLsizei(depth), GLint(border), GLenum(format), GLenum(type), c_void_p(pixels) ) -> None
glTexImage3D( target,level,internalformat,border,format,pixels )
pyConverters: target=None, level=None, internalformat=None, border=None, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x87be90c>
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
, depth=
depth(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the depth 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, depth=None, border=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexImage3D( GLenum(target), GLint(level), GLint(internalformat), GLsizei(width), GLsizei(height), GLsizei(depth), GLint(border), GLenum(format), GLenum(type), c_void_p(pixels) ) -> None
glTexImage3D( target,level,internalformat,border,format,pixels )
pyConverters: target=None, level=None, internalformat=None, border=None, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x87bed8c>
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
, depth=
depth(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the depth 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, depth=None, border=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexImage3D( GLenum(target), GLint(level), GLint(internalformat), GLsizei(width), GLsizei(height), GLsizei(depth), GLint(border), GLenum(format), GLenum(type), c_void_p(pixels) ) -> None
glTexImage3D( target,level,internalformat,border,format,pixels )
pyConverters: target=None, level=None, internalformat=None, border=None, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x87be0ec>
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
, depth=
depth(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the depth 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, depth=None, border=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexImage3D( GLenum(target), GLint(level), GLint(internalformat), GLsizei(width), GLsizei(height), GLsizei(depth), GLint(border), GLenum(format), GLenum(type), c_void_p(pixels) ) -> None
glTexImage3D( target,level,internalformat,border,format,pixels )
pyConverters: target=None, level=None, internalformat=None, border=None, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x87be56c>
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
, depth=
depth(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the depth 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, depth=None, border=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexImage3D( GLenum(target), GLint(level), GLint(internalformat), GLsizei(width), GLsizei(height), GLsizei(depth), GLint(border), GLenum(format), GLenum(type), c_void_p(pixels) ) -> None
glTexImage3D( target,level,internalformat,border,format,pixels )
pyConverters: target=None, level=None, internalformat=None, border=None, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x87befec>
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
, depth=
depth(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the depth 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, depth=None, border=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexImage3D( GLenum(target), GLint(level), GLint(internalformat), GLsizei(width), GLsizei(height), GLsizei(depth), GLint(border), GLenum(format), GLenum(type), c_void_p(pixels) ) -> None
glTexImage3D( target,level,internalformat,border,format,pixels )
pyConverters: target=None, level=None, internalformat=None, border=None, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x827f8ec>
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
, depth=
depth(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the depth 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, depth=None, border=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexImage3D( GLenum(target), GLint(level), GLint(internalformat), GLsizei(width), GLsizei(height), GLsizei(depth), GLint(border), GLenum(format), GLenum(type), c_void_p(pixels) ) -> None
glTexSubImage3D( target,level,xoffset,yoffset,zoffset,width,height,depth,format,type,pixels )
pyConverters: target=None, level=None, xoffset=
asIntConverter(value, *args)
, yoffset=
asIntConverter(value, *args)
, zoffset=
asIntConverter(value, *args)
, width=
asIntConverter(value, *args)
, height=
asIntConverter(value, *args)
, depth=
asIntConverter(value, *args)
, format=None, type=None, pixels=<OpenGL.GL.images.ImageInputConverter object at 0x827f7cc>
cConverters: Not Used
cResolvers: target=None, level=None, xoffset=None, yoffset=None, zoffset=None, width=None, height=None, depth=None, format=None, type=None, pixels=
cResolver(self, array) method of ImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexSubImage3D( GLenum(target), GLint(level), GLint(xoffset), GLint(yoffset), GLint(zoffset), GLsizei(width), GLsizei(height), GLsizei(depth), GLenum(format), GLenum(type), c_void_p(pixels) ) -> None
glTexSubImage3D( target,level,xoffset,yoffset,zoffset,format,pixels )
pyConverters: target=None, level=None, xoffset=
asIntConverter(value, *args)
, yoffset=
asIntConverter(value, *args)
, zoffset=
asIntConverter(value, *args)
, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x87be76c>
cConverters: target=None, level=None, xoffset=None, yoffset=None, zoffset=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
, depth=
depth(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the depth 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, zoffset=None, width=None, height=None, depth=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexSubImage3D( GLenum(target), GLint(level), GLint(xoffset), GLint(yoffset), GLint(zoffset), GLsizei(width), GLsizei(height), GLsizei(depth), GLenum(format), GLenum(type), c_void_p(pixels) ) -> None
glTexSubImage3D( target,level,xoffset,yoffset,zoffset,format,pixels )
pyConverters: target=None, level=None, xoffset=
asIntConverter(value, *args)
, yoffset=
asIntConverter(value, *args)
, zoffset=
asIntConverter(value, *args)
, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x87be16c>
cConverters: target=None, level=None, xoffset=None, yoffset=None, zoffset=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
, depth=
depth(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the depth 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, zoffset=None, width=None, height=None, depth=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexSubImage3D( GLenum(target), GLint(level), GLint(xoffset), GLint(yoffset), GLint(zoffset), GLsizei(width), GLsizei(height), GLsizei(depth), GLenum(format), GLenum(type), c_void_p(pixels) ) -> None
glTexSubImage3D( target,level,xoffset,yoffset,zoffset,format,pixels )
pyConverters: target=None, level=None, xoffset=
asIntConverter(value, *args)
, yoffset=
asIntConverter(value, *args)
, zoffset=
asIntConverter(value, *args)
, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x87be74c>
cConverters: target=None, level=None, xoffset=None, yoffset=None, zoffset=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
, depth=
depth(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the depth 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, zoffset=None, width=None, height=None, depth=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexSubImage3D( GLenum(target), GLint(level), GLint(xoffset), GLint(yoffset), GLint(zoffset), GLsizei(width), GLsizei(height), GLsizei(depth), GLenum(format), GLenum(type), c_void_p(pixels) ) -> None
glTexSubImage3D( target,level,xoffset,yoffset,zoffset,format,pixels )
pyConverters: target=None, level=None, xoffset=
asIntConverter(value, *args)
, yoffset=
asIntConverter(value, *args)
, zoffset=
asIntConverter(value, *args)
, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x87bedcc>
cConverters: target=None, level=None, xoffset=None, yoffset=None, zoffset=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
, depth=
depth(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the depth 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, zoffset=None, width=None, height=None, depth=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexSubImage3D( GLenum(target), GLint(level), GLint(xoffset), GLint(yoffset), GLint(zoffset), GLsizei(width), GLsizei(height), GLsizei(depth), GLenum(format), GLenum(type), c_void_p(pixels) ) -> None
glTexSubImage3D( target,level,xoffset,yoffset,zoffset,format,pixels )
pyConverters: target=None, level=None, xoffset=
asIntConverter(value, *args)
, yoffset=
asIntConverter(value, *args)
, zoffset=
asIntConverter(value, *args)
, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x87be36c>
cConverters: target=None, level=None, xoffset=None, yoffset=None, zoffset=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
, depth=
depth(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the depth 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, zoffset=None, width=None, height=None, depth=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexSubImage3D( GLenum(target), GLint(level), GLint(xoffset), GLint(yoffset), GLint(zoffset), GLsizei(width), GLsizei(height), GLsizei(depth), GLenum(format), GLenum(type), c_void_p(pixels) ) -> None
glTexSubImage3D( target,level,xoffset,yoffset,zoffset,format,pixels )
pyConverters: target=None, level=None, xoffset=
asIntConverter(value, *args)
, yoffset=
asIntConverter(value, *args)
, zoffset=
asIntConverter(value, *args)
, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x827f54c>
cConverters: target=None, level=None, xoffset=None, yoffset=None, zoffset=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
, depth=
depth(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the depth 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, zoffset=None, width=None, height=None, depth=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexSubImage3D( GLenum(target), GLint(level), GLint(xoffset), GLint(yoffset), GLint(zoffset), GLsizei(width), GLsizei(height), GLsizei(depth), GLenum(format), GLenum(type), c_void_p(pixels) ) -> None
glTexSubImage3D( target,level,xoffset,yoffset,zoffset,format,pixels )
pyConverters: target=None, level=None, xoffset=
asIntConverter(value, *args)
, yoffset=
asIntConverter(value, *args)
, zoffset=
asIntConverter(value, *args)
, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x827f80c>
cConverters: target=None, level=None, xoffset=None, yoffset=None, zoffset=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
, depth=
depth(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance
Extract the depth 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, zoffset=None, width=None, height=None, depth=None, format=None, type=None, pixels=
cResolver(self, array) method of TypedImageInputConverter instance
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glTexSubImage3D( GLenum(target), GLint(level), GLint(xoffset), GLint(yoffset), GLint(zoffset), GLsizei(width), GLsizei(height), GLsizei(depth), GLenum(format), GLenum(type), c_void_p(pixels) ) -> None

 
Data
        GL_GET_CP_SIZES = {GL_CONVOLUTION_BORDER_MODE: 1, GL_CONVOLUTION_FILTER_SCALE: 4, GL_CONVOLUTION_FILTER_BIAS: 4, GL_CONVOLUTION_FORMAT: 1, GL_CONVOLUTION_WIDTH: 1, GL_CONVOLUTION_HEIGHT: 1, GL_MAX_CONVOLUTION_WIDTH: 1, GL_MAX_CONVOLUTION_HEIGHT: 1, GL_CONVOLUTION_BORDER_COLOR: 4}
GL_GET_CTP_SIZES = {GL_COLOR_TABLE_FORMAT: 1, GL_COLOR_TABLE_WIDTH: 1, GL_COLOR_TABLE_RED_SIZE: 1, GL_COLOR_TABLE_GREEN_SIZE: 1, GL_COLOR_TABLE_BLUE_SIZE: 1, GL_COLOR_TABLE_ALPHA_SIZE: 1, GL_COLOR_TABLE_LUMINANCE_SIZE: 1, GL_COLOR_TABLE_INTENSITY_SIZE: 1}
__file__ = '/build/buildd/pyopengl-3.0.0~b3/OpenGL/GL/VERSION/GL_1_2_images.py'
__name__ = 'OpenGL.GL.VERSION.GL_1_2_images'