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

OpenGL extension VERSION.GL_1_3
 
This module customises the behaviour of the 
OpenGL.raw.GL.VERSION.GL_1_3 to provide a more 
Python-friendly API

 
Modules
       
OpenGL.arrays
OpenGL.constant
OpenGL.constants
ctypes
OpenGL.extensions
OpenGL.GL.glget
OpenGL.GL.images
OpenGL.platform
OpenGL.raw.GL.VERSION.GL_1_3
OpenGL.wrapper

 
Functions
       
glActiveTexture(...)
glActiveTexture( GLenum(texture) ) -> None
glClientActiveTexture(...)
glClientActiveTexture( GLenum(texture) ) -> None
glCompressedTexImage1D( target,level,internalformat,width,border,data )
pyConverters: target=None, level=None, internalformat=None, width=
asIntConverter(value, *args)
, border=None, data=None
cConverters: target=None, level=None, internalformat=None, width=None, border=None, imageSize=<OpenGL.GL.images.CompressedImageConverter object at 0x823e56c>, data=None
cResolvers: Not Used
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glCompressedTexImage1D( GLenum(target), GLint(level), GLenum(internalformat), GLsizei(width), GLint(border), GLsizei(imageSize), c_void_p(data) ) -> None
glCompressedTexImage2D( target,level,internalformat,width,height,border,data )
pyConverters: target=None, level=None, internalformat=None, width=
asIntConverter(value, *args)
, height=
asIntConverter(value, *args)
, border=None, data=None
cConverters: target=None, level=None, internalformat=None, width=None, height=None, border=None, imageSize=<OpenGL.GL.images.CompressedImageConverter object at 0x823e7ec>, data=None
cResolvers: Not Used
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glCompressedTexImage2D( GLenum(target), GLint(level), GLenum(internalformat), GLsizei(width), GLsizei(height), GLint(border), GLsizei(imageSize), c_void_p(data) ) -> None
glCompressedTexImage3D( target,level,internalformat,width,height,depth,border,data )
pyConverters: target=None, level=None, internalformat=None, width=
asIntConverter(value, *args)
, height=
asIntConverter(value, *args)
, depth=
asIntConverter(value, *args)
, border=None, data=None
cConverters: target=None, level=None, internalformat=None, width=None, height=None, depth=None, border=None, imageSize=<OpenGL.GL.images.CompressedImageConverter object at 0x828abcc>, data=None
cResolvers: Not Used
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glCompressedTexImage3D( GLenum(target), GLint(level), GLenum(internalformat), GLsizei(width), GLsizei(height), GLsizei(depth), GLint(border), GLsizei(imageSize), c_void_p(data) ) -> None
glCompressedTexSubImage1D( target,level,xoffset,width,format,data )
pyConverters: target=None, level=None, xoffset=
asIntConverter(value, *args)
, width=
asIntConverter(value, *args)
, format=None, data=None
cConverters: target=None, level=None, xoffset=None, width=None, format=None, imageSize=<OpenGL.GL.images.CompressedImageConverter object at 0x823e60c>, data=None
cResolvers: Not Used
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glCompressedTexSubImage1D( GLenum(target), GLint(level), GLint(xoffset), GLsizei(width), GLenum(format), GLsizei(imageSize), c_void_p(data) ) -> None
glCompressedTexSubImage2D( target,level,xoffset,yoffset,width,height,format,data )
pyConverters: target=None, level=None, xoffset=
asIntConverter(value, *args)
, yoffset=
asIntConverter(value, *args)
, width=
asIntConverter(value, *args)
, height=
asIntConverter(value, *args)
, format=None, data=None
cConverters: target=None, level=None, xoffset=None, yoffset=None, width=None, height=None, format=None, imageSize=<OpenGL.GL.images.CompressedImageConverter object at 0x828a7ec>, data=None
cResolvers: Not Used
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glCompressedTexSubImage2D( GLenum(target), GLint(level), GLint(xoffset), GLint(yoffset), GLsizei(width), GLsizei(height), GLenum(format), GLsizei(imageSize), c_void_p(data) ) -> None
glCompressedTexSubImage3D( target,level,xoffset,yoffset,zoffset,width,height,depth,format,data )
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, data=None
cConverters: target=None, level=None, xoffset=None, yoffset=None, zoffset=None, width=None, height=None, depth=None, format=None, imageSize=<OpenGL.GL.images.CompressedImageConverter object at 0x828a6ac>, data=None
cResolvers: Not Used
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glCompressedTexSubImage3D( GLenum(target), GLint(level), GLint(xoffset), GLint(yoffset), GLint(zoffset), GLsizei(width), GLsizei(height), GLsizei(depth), GLenum(format), GLsizei(imageSize), c_void_p(data) ) -> None
glLoadTransposeMatrixd( m )
pyConverters: m=
asArraySize(incoming, function, args)
cConverters: m=<OpenGL.converters.getPyArgsName object at 0x878243c>
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: glLoadTransposeMatrixd( GLdoubleArray(m) ) -> None
glLoadTransposeMatrixf( m )
pyConverters: m=
asArraySize(incoming, function, args)
cConverters: m=<OpenGL.converters.getPyArgsName object at 0x878257c>
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: glLoadTransposeMatrixf( GLfloatArray(m) ) -> None
glMultTransposeMatrixd( m )
pyConverters: m=
asArraySize(incoming, function, args)
cConverters: m=<OpenGL.converters.getPyArgsName object at 0x87824dc>
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: glMultTransposeMatrixd( GLdoubleArray(m) ) -> None
glMultTransposeMatrixf( m )
pyConverters: m=
asArraySize(incoming, function, args)
cConverters: m=<OpenGL.converters.getPyArgsName object at 0x878261c>
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: glMultTransposeMatrixf( GLfloatArray(m) ) -> None
glMultiTexCoord1d(...)
glMultiTexCoord1d( GLenum(target), GLdouble(s) ) -> None
glMultiTexCoord1dv( target,v )
pyConverters: target=None, v=
asArraySize(incoming, function, args)
cConverters: target=None, v=<OpenGL.converters.getPyArgsName object at 0x851ca04>
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: glMultiTexCoord1dv( GLenum(target), GLdoubleArray(v) ) -> None
glMultiTexCoord1f(...)
glMultiTexCoord1f( GLenum(target), GLfloat(s) ) -> None
glMultiTexCoord1fv( target,v )
pyConverters: target=None, v=
asArraySize(incoming, function, args)
cConverters: target=None, v=<OpenGL.converters.getPyArgsName object at 0x851cc84>
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: glMultiTexCoord1fv( GLenum(target), GLfloatArray(v) ) -> None
glMultiTexCoord1i(...)
glMultiTexCoord1i( GLenum(target), GLint(s) ) -> None
glMultiTexCoord1iv( target,v )
pyConverters: target=None, v=
asArraySize(incoming, function, args)
cConverters: target=None, v=<OpenGL.converters.getPyArgsName object at 0x851cf04>
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: glMultiTexCoord1iv( GLenum(target), GLintArray(v) ) -> None
glMultiTexCoord1s(...)
glMultiTexCoord1s( GLenum(target), GLshort(s) ) -> None
glMultiTexCoord1sv( target,v )
pyConverters: target=None, v=
asArraySize(incoming, function, args)
cConverters: target=None, v=<OpenGL.converters.getPyArgsName object at 0x87821bc>
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: glMultiTexCoord1sv( GLenum(target), GLshortArray(v) ) -> None
glMultiTexCoord2d(...)
glMultiTexCoord2d( GLenum(target), GLdouble(s), GLdouble(t) ) -> None
glMultiTexCoord2dv( target,v )
pyConverters: target=None, v=
asArraySize(incoming, function, args)
cConverters: target=None, v=<OpenGL.converters.getPyArgsName object at 0x851caa4>
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: glMultiTexCoord2dv( GLenum(target), GLdoubleArray(v) ) -> None
glMultiTexCoord2f(...)
glMultiTexCoord2f( GLenum(target), GLfloat(s), GLfloat(t) ) -> None
glMultiTexCoord2fv( target,v )
pyConverters: target=None, v=
asArraySize(incoming, function, args)
cConverters: target=None, v=<OpenGL.converters.getPyArgsName object at 0x851cd24>
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: glMultiTexCoord2fv( GLenum(target), GLfloatArray(v) ) -> None
glMultiTexCoord2i(...)
glMultiTexCoord2i( GLenum(target), GLint(s), GLint(t) ) -> None
glMultiTexCoord2iv( target,v )
pyConverters: target=None, v=
asArraySize(incoming, function, args)
cConverters: target=None, v=<OpenGL.converters.getPyArgsName object at 0x851cfa4>
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: glMultiTexCoord2iv( GLenum(target), GLintArray(v) ) -> None
glMultiTexCoord2s(...)
glMultiTexCoord2s( GLenum(target), GLshort(s), GLshort(t) ) -> None
glMultiTexCoord2sv( target,v )
pyConverters: target=None, v=
asArraySize(incoming, function, args)
cConverters: target=None, v=<OpenGL.converters.getPyArgsName object at 0x878225c>
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: glMultiTexCoord2sv( GLenum(target), GLshortArray(v) ) -> None
glMultiTexCoord3d(...)
glMultiTexCoord3d( GLenum(target), GLdouble(s), GLdouble(t), GLdouble(r) ) -> None
glMultiTexCoord3dv( target,v )
pyConverters: target=None, v=
asArraySize(incoming, function, args)
cConverters: target=None, v=<OpenGL.converters.getPyArgsName object at 0x851cb44>
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: glMultiTexCoord3dv( GLenum(target), GLdoubleArray(v) ) -> None
glMultiTexCoord3f(...)
glMultiTexCoord3f( GLenum(target), GLfloat(s), GLfloat(t), GLfloat(r) ) -> None
glMultiTexCoord3fv( target,v )
pyConverters: target=None, v=
asArraySize(incoming, function, args)
cConverters: target=None, v=<OpenGL.converters.getPyArgsName object at 0x851cdc4>
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: glMultiTexCoord3fv( GLenum(target), GLfloatArray(v) ) -> None
glMultiTexCoord3i(...)
glMultiTexCoord3i( GLenum(target), GLint(s), GLint(t), GLint(r) ) -> None
glMultiTexCoord3iv( target,v )
pyConverters: target=None, v=
asArraySize(incoming, function, args)
cConverters: target=None, v=<OpenGL.converters.getPyArgsName object at 0x878207c>
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: glMultiTexCoord3iv( GLenum(target), GLintArray(v) ) -> None
glMultiTexCoord3s(...)
glMultiTexCoord3s( GLenum(target), GLshort(s), GLshort(t), GLshort(r) ) -> None
glMultiTexCoord3sv( target,v )
pyConverters: target=None, v=
asArraySize(incoming, function, args)
cConverters: target=None, v=<OpenGL.converters.getPyArgsName object at 0x87822fc>
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: glMultiTexCoord3sv( GLenum(target), GLshortArray(v) ) -> None
glMultiTexCoord4d(...)
glMultiTexCoord4d( GLenum(target), GLdouble(s), GLdouble(t), GLdouble(r), GLdouble(q) ) -> None
glMultiTexCoord4dv( target,v )
pyConverters: target=None, v=
asArraySize(incoming, function, args)
cConverters: target=None, v=<OpenGL.converters.getPyArgsName object at 0x851cbe4>
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: glMultiTexCoord4dv( GLenum(target), GLdoubleArray(v) ) -> None
glMultiTexCoord4f(...)
glMultiTexCoord4f( GLenum(target), GLfloat(s), GLfloat(t), GLfloat(r), GLfloat(q) ) -> None
glMultiTexCoord4fv( target,v )
pyConverters: target=None, v=
asArraySize(incoming, function, args)
cConverters: target=None, v=<OpenGL.converters.getPyArgsName object at 0x851ce64>
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: glMultiTexCoord4fv( GLenum(target), GLfloatArray(v) ) -> None
glMultiTexCoord4i(...)
glMultiTexCoord4i( GLenum(target), GLint(s), GLint(t), GLint(r), GLint(q) ) -> None
glMultiTexCoord4iv( target,v )
pyConverters: target=None, v=
asArraySize(incoming, function, args)
cConverters: target=None, v=<OpenGL.converters.getPyArgsName object at 0x878211c>
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: glMultiTexCoord4iv( GLenum(target), GLintArray(v) ) -> None
glMultiTexCoord4s(...)
glMultiTexCoord4s( GLenum(target), GLshort(s), GLshort(t), GLshort(r), GLshort(q) ) -> None
glMultiTexCoord4sv( target,v )
pyConverters: target=None, v=
asArraySize(incoming, function, args)
cConverters: target=None, v=<OpenGL.converters.getPyArgsName object at 0x878239c>
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: glMultiTexCoord4sv( GLenum(target), GLshortArray(v) ) -> None
glSampleCoverage(...)
glSampleCoverage( GLclampf(value), GLboolean(invert) ) -> None

 
Data
        GL_ACTIVE_TEXTURE = GL_ACTIVE_TEXTURE
GL_ADD_SIGNED = GL_ADD_SIGNED
GL_CLAMP_TO_BORDER = GL_CLAMP_TO_BORDER
GL_CLIENT_ACTIVE_TEXTURE = GL_CLIENT_ACTIVE_TEXTURE
GL_COMBINE = GL_COMBINE
GL_COMBINE_ALPHA = GL_COMBINE_ALPHA
GL_COMBINE_RGB = GL_COMBINE_RGB
GL_COMPRESSED_ALPHA = GL_COMPRESSED_ALPHA
GL_COMPRESSED_INTENSITY = GL_COMPRESSED_INTENSITY
GL_COMPRESSED_LUMINANCE = GL_COMPRESSED_LUMINANCE
GL_COMPRESSED_LUMINANCE_ALPHA = GL_COMPRESSED_LUMINANCE_ALPHA
GL_COMPRESSED_RGB = GL_COMPRESSED_RGB
GL_COMPRESSED_RGBA = GL_COMPRESSED_RGBA
GL_COMPRESSED_TEXTURE_FORMATS = GL_COMPRESSED_TEXTURE_FORMATS
GL_CONSTANT = GL_CONSTANT
GL_DOT3_RGB = GL_DOT3_RGB
GL_DOT3_RGBA = GL_DOT3_RGBA
GL_INTERPOLATE = GL_INTERPOLATE
GL_MAX_CUBE_MAP_TEXTURE_SIZE = GL_MAX_CUBE_MAP_TEXTURE_SIZE
GL_MAX_TEXTURE_UNITS = GL_MAX_TEXTURE_UNITS
GL_MULTISAMPLE = GL_MULTISAMPLE
GL_MULTISAMPLE_BIT = GL_MULTISAMPLE_BIT
GL_NORMAL_MAP = GL_NORMAL_MAP
GL_NUM_COMPRESSED_TEXTURE_FORMATS = GL_NUM_COMPRESSED_TEXTURE_FORMATS
GL_OPERAND0_ALPHA = GL_OPERAND0_ALPHA
GL_OPERAND0_RGB = GL_OPERAND0_RGB
GL_OPERAND1_ALPHA = GL_OPERAND1_ALPHA
GL_OPERAND1_RGB = GL_OPERAND1_RGB
GL_OPERAND2_ALPHA = GL_OPERAND2_ALPHA
GL_OPERAND2_RGB = GL_OPERAND2_RGB
GL_PREVIOUS = GL_PREVIOUS
GL_PRIMARY_COLOR = GL_PRIMARY_COLOR
GL_PROXY_TEXTURE_CUBE_MAP = GL_PROXY_TEXTURE_CUBE_MAP
GL_REFLECTION_MAP = GL_REFLECTION_MAP
GL_RGB_SCALE = GL_RGB_SCALE
GL_SAMPLES = GL_SAMPLES
GL_SAMPLE_ALPHA_TO_COVERAGE = GL_SAMPLE_ALPHA_TO_COVERAGE
GL_SAMPLE_ALPHA_TO_ONE = GL_SAMPLE_ALPHA_TO_ONE
GL_SAMPLE_BUFFERS = GL_SAMPLE_BUFFERS
GL_SAMPLE_COVERAGE = GL_SAMPLE_COVERAGE
GL_SAMPLE_COVERAGE_INVERT = GL_SAMPLE_COVERAGE_INVERT
GL_SAMPLE_COVERAGE_VALUE = GL_SAMPLE_COVERAGE_VALUE
GL_SOURCE0_ALPHA = GL_SOURCE0_ALPHA
GL_SOURCE0_RGB = GL_SOURCE0_RGB
GL_SOURCE1_ALPHA = GL_SOURCE1_ALPHA
GL_SOURCE1_RGB = GL_SOURCE1_RGB
GL_SOURCE2_ALPHA = GL_SOURCE2_ALPHA
GL_SOURCE2_RGB = GL_SOURCE2_RGB
GL_SUBTRACT = GL_SUBTRACT
GL_TEXTURE0 = GL_TEXTURE0
GL_TEXTURE1 = GL_TEXTURE1
GL_TEXTURE10 = GL_TEXTURE10
GL_TEXTURE11 = GL_TEXTURE11
GL_TEXTURE12 = GL_TEXTURE12
GL_TEXTURE13 = GL_TEXTURE13
GL_TEXTURE14 = GL_TEXTURE14
GL_TEXTURE15 = GL_TEXTURE15
GL_TEXTURE16 = GL_TEXTURE16
GL_TEXTURE17 = GL_TEXTURE17
GL_TEXTURE18 = GL_TEXTURE18
GL_TEXTURE19 = GL_TEXTURE19
GL_TEXTURE2 = GL_TEXTURE2
GL_TEXTURE20 = GL_TEXTURE20
GL_TEXTURE21 = GL_TEXTURE21
GL_TEXTURE22 = GL_TEXTURE22
GL_TEXTURE23 = GL_TEXTURE23
GL_TEXTURE24 = GL_TEXTURE24
GL_TEXTURE25 = GL_TEXTURE25
GL_TEXTURE26 = GL_TEXTURE26
GL_TEXTURE27 = GL_TEXTURE27
GL_TEXTURE28 = GL_TEXTURE28
GL_TEXTURE29 = GL_TEXTURE29
GL_TEXTURE3 = GL_TEXTURE3
GL_TEXTURE30 = GL_TEXTURE30
GL_TEXTURE31 = GL_TEXTURE31
GL_TEXTURE4 = GL_TEXTURE4
GL_TEXTURE5 = GL_TEXTURE5
GL_TEXTURE6 = GL_TEXTURE6
GL_TEXTURE7 = GL_TEXTURE7
GL_TEXTURE8 = GL_TEXTURE8
GL_TEXTURE9 = GL_TEXTURE9
GL_TEXTURE_BINDING_CUBE_MAP = GL_TEXTURE_BINDING_CUBE_MAP
GL_TEXTURE_COMPRESSED = GL_TEXTURE_COMPRESSED
GL_TEXTURE_COMPRESSED_IMAGE_SIZE = GL_TEXTURE_COMPRESSED_IMAGE_SIZE
GL_TEXTURE_COMPRESSION_HINT = GL_TEXTURE_COMPRESSION_HINT
GL_TEXTURE_CUBE_MAP = GL_TEXTURE_CUBE_MAP
GL_TEXTURE_CUBE_MAP_NEGATIVE_X = GL_TEXTURE_CUBE_MAP_NEGATIVE_X
GL_TEXTURE_CUBE_MAP_NEGATIVE_Y = GL_TEXTURE_CUBE_MAP_NEGATIVE_Y
GL_TEXTURE_CUBE_MAP_NEGATIVE_Z = GL_TEXTURE_CUBE_MAP_NEGATIVE_Z
GL_TEXTURE_CUBE_MAP_POSITIVE_X = GL_TEXTURE_CUBE_MAP_POSITIVE_X
GL_TEXTURE_CUBE_MAP_POSITIVE_Y = GL_TEXTURE_CUBE_MAP_POSITIVE_Y
GL_TEXTURE_CUBE_MAP_POSITIVE_Z = GL_TEXTURE_CUBE_MAP_POSITIVE_Z
GL_TRANSPOSE_COLOR_MATRIX = GL_TRANSPOSE_COLOR_MATRIX
GL_TRANSPOSE_MODELVIEW_MATRIX = GL_TRANSPOSE_MODELVIEW_MATRIX
GL_TRANSPOSE_PROJECTION_MATRIX = GL_TRANSPOSE_PROJECTION_MATRIX
GL_TRANSPOSE_TEXTURE_MATRIX = GL_TRANSPOSE_TEXTURE_MATRIX
__file__ = '/build/buildd/pyopengl-3.0.0~b3/OpenGL/GL/VERSION/GL_1_3.py'
__name__ = 'OpenGL.GL.VERSION.GL_1_3'