PyOpenGL 3.1.9a2__tar.gz → 4.0.0a1__tar.gz

pyopengl-4.0.0a1/OpenGL/GL/AMD/vertex_shader_tessellator.py

@@ -0,0 +1,88 @@
+'''OpenGL extension AMD.vertex_shader_tessellator
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.AMD.vertex_shader_tessellator to provide a more 
+Python-friendly API
+
+Overview (from the spec)
+	
+	The vertex shader tessellator gives new flexibility to the shader
+	author to shade at a tessellated vertex, rather than just at a
+	provided vertex.
+	
+	In unextended vertex shading, the built-in attributes such as
+	gl_Vertex, gl_Normal, and gl_MultiTexcoord0, together with the
+	user defined attributes, are system provided values which are
+	initialized prior to vertex shader invocation.
+	
+	With vertex shading tessellation, additional vertex shader special 
+	values are available:
+	
+	    ivec3 gl_VertexTriangleIndex; // indices of the three control
+	                                  // points for the vertex
+	    vec3 gl_BarycentricCoord;     // barycentric coordinates
+	                                  // of the vertex
+	
+	i o
+	  |\\
+	  | \\
+	  *--*
+	  |\\ |\\
+	  | \\| \\
+	  *--*--*
+	  |\\ |\\ |\\
+	  | \\| \\| \\
+	j o--*--*--o k
+	
+	Figure 1  A Tessellated Triangle
+	o = control point (and tessellated vertex)
+	* = tessellated vertex
+	
+	    ivec4 gl_VertexQuadIndex;   // indices for the four control
+	                                // points for the vertex
+	    vec2 gl_UVCoord;            // UV coordinates of the vertex
+	
+	i o--*--*--o k
+	  |\\ |\\ |\\ | 
+	  | \\| \\| \\|
+	  *--*--*--*
+	  |\\ |\\ |\\ | 
+	  | \\| \\| \\|
+	  *--*--*--*
+	  |\\ |\\ |\\ | 
+	  | \\| \\| \\|
+	j o--*--*--o l
+	
+	Figure 2  A Tessellated Quad
+	o = control point (and tessellated vertex)
+	* = tessellated vertex
+	
+	When this extension is enabled, conventional built-in attributes
+	and user defined attributes are uninitialized.  The shader writer
+	is responsible for explicitly fetching all other vertex data either
+	from textures, uniform buffers, or vertex buffers.
+	
+	The shader writer is further responsible for interpolating 
+	the vertex data at the given barycentric coordinates or uv
+	coordinates of the vertex.
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/AMD/vertex_shader_tessellator.txt
+'''
+
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.GL import _types, _glgets
+from OpenGL.raw.GL.AMD.vertex_shader_tessellator import *
+from OpenGL.raw.GL.AMD.vertex_shader_tessellator import _EXTENSION_NAME
+
+
+def glInitVertexShaderTessellatorAMD():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+
+    return extensions.hasGLExtension(_EXTENSION_NAME)
+
+
+### END AUTOGENERATED SECTION

pyopengl-4.0.0a1/OpenGL/GL/ARB/imaging.py

@@ -0,0 +1,236 @@
+'''OpenGL extension ARB.imaging
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.ARB.imaging to provide a more 
+Python-friendly API
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/ARB/imaging.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.GL import _types, _glgets
+from OpenGL.raw.GL.ARB.imaging import *
+from OpenGL.raw.GL.ARB.imaging import _EXTENSION_NAME
+
+def glInitImagingARB():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+def _get_scalar(value):
+    """Extract scalar from array or return scalar directly.
+
+    Handles both array returns and scalar returns from glGet functions
+    when SIZE_1_ARRAY_UNPACK is enabled.
+    """
+    try:
+        return value[0]
+    except (IndexError, TypeError):
+        return value
+
+# INPUT glColorTable.table size not checked against 'format,type,width'
+glColorTable=wrapper.wrapper(glColorTable).setInputArraySize(
+    'table', None
+)
+# INPUT glColorTableParameterfv.params size not checked against 'pname'
+glColorTableParameterfv=wrapper.wrapper(glColorTableParameterfv).setInputArraySize(
+    'params', None
+)
+# INPUT glColorTableParameteriv.params size not checked against 'pname'
+glColorTableParameteriv=wrapper.wrapper(glColorTableParameteriv).setInputArraySize(
+    'params', None
+)
+# OUTPUT glGetColorTable.table COMPSIZE(target, format, type) 
+glGetColorTableParameterfv=wrapper.wrapper(glGetColorTableParameterfv).setOutput(
+    'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True
+)
+glGetColorTableParameteriv=wrapper.wrapper(glGetColorTableParameteriv).setOutput(
+    'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True
+)
+# INPUT glColorSubTable.data size not checked against 'format,type,count'
+glColorSubTable=wrapper.wrapper(glColorSubTable).setInputArraySize(
+    'data', None
+)
+# INPUT glConvolutionFilter1D.image size not checked against 'format,type,width'
+glConvolutionFilter1D=wrapper.wrapper(glConvolutionFilter1D).setInputArraySize(
+    'image', None
+)
+# INPUT glConvolutionFilter2D.image size not checked against 'format,type,width,height'
+glConvolutionFilter2D=wrapper.wrapper(glConvolutionFilter2D).setInputArraySize(
+    'image', None
+)
+# INPUT glConvolutionParameterfv.params size not checked against 'pname'
+glConvolutionParameterfv=wrapper.wrapper(glConvolutionParameterfv).setInputArraySize(
+    'params', None
+)
+# INPUT glConvolutionParameteriv.params size not checked against 'pname'
+glConvolutionParameteriv=wrapper.wrapper(glConvolutionParameteriv).setInputArraySize(
+    'params', None
+)
+# OUTPUT glGetConvolutionFilter.image COMPSIZE(target, format, type) 
+glGetConvolutionParameterfv=wrapper.wrapper(glGetConvolutionParameterfv).setOutput(
+    'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True
+)
+glGetConvolutionParameteriv=wrapper.wrapper(glGetConvolutionParameteriv).setOutput(
+    'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True
+)
+# OUTPUT glGetSeparableFilter.column COMPSIZE(target, format, type) 
+# OUTPUT glGetSeparableFilter.row COMPSIZE(target, format, type) 
+# OUTPUT glGetSeparableFilter.span COMPSIZE(target, format, type) 
+# INPUT glSeparableFilter2D.column size not checked against 'target,format,type,height'
+# INPUT glSeparableFilter2D.row size not checked against 'target,format,type,width'
+glSeparableFilter2D=wrapper.wrapper(glSeparableFilter2D).setInputArraySize(
+    'column', None
+).setInputArraySize(
+    'row', None
+)
+# OUTPUT glGetHistogram.values COMPSIZE(target, format, type) 
+glGetHistogramParameterfv=wrapper.wrapper(glGetHistogramParameterfv).setOutput(
+    'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True
+)
+glGetHistogramParameteriv=wrapper.wrapper(glGetHistogramParameteriv).setOutput(
+    'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True
+)
+# OUTPUT glGetMinmax.values COMPSIZE(target, format, type) 
+glGetMinmaxParameterfv=wrapper.wrapper(glGetMinmaxParameterfv).setOutput(
+    'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True
+)
+glGetMinmaxParameteriv=wrapper.wrapper(glGetMinmaxParameteriv).setOutput(
+    'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True
+)
+### END AUTOGENERATED SECTION
+from OpenGL.GL import images
+from OpenGL.lazywrapper import lazy as _lazy
+glColorTable = images.setDimensionsAsInts(
+    images.setImageInput(
+        glColorTable,
+        pixelName = 'table',
+        typeName = 'type',
+    )
+)
+glColorSubTable = images.setDimensionsAsInts(
+    images.setImageInput(
+        glColorSubTable,
+        pixelName = 'data',
+    )
+)
+glSeparableFilter2D = images.setDimensionsAsInts(
+    images.setImageInput(
+        images.setImageInput(
+            glSeparableFilter2D,
+            pixelName = 'row',
+            typeName = 'type',
+        ),
+        pixelName = 'column',
+        typeName = 'type',
+    )
+)
+glConvolutionFilter1D = images.setDimensionsAsInts(
+    images.setImageInput(
+        glConvolutionFilter1D,
+        pixelName = 'image',
+        typeName = 'type',
+    )
+)
+glConvolutionFilter2D = images.setDimensionsAsInts(
+    images.setImageInput(
+        glConvolutionFilter2D,
+        pixelName = 'image',
+        typeName = 'type',
+    )
+)
+
+@_lazy( glGetConvolutionFilter )
+def glGetConvolutionFilter( baseFunction, target, format, type ):
+    """Retrieve 1 or 2D convolution parameter "kernels" as pixel data"""
+    dims = (
+        _get_scalar(glGetConvolutionParameteriv( target, GL_CONVOLUTION_WIDTH )),
+    )
+    if target != GL_CONVOLUTION_1D:
+        dims += (
+            _get_scalar(glGetConvolutionParameteriv( target, GL_CONVOLUTION_HEIGHT )),
+        )
+    # is it always 4?  Seems to be, but the spec/man-page isn't really clear about it...
+    dims += (4,)
+    array = images.images.SetupPixelRead( format, dims, type )
+    arrayType = arrays.GL_CONSTANT_TO_ARRAY_TYPE[
+        images.images.TYPE_TO_ARRAYTYPE.get(type,type)
+    ]
+    baseFunction(
+        target, format, type,
+        ctypes.c_void_p( arrayType.dataPointer(array))
+    )
+    return array
+@_lazy( glGetSeparableFilter )
+def glGetSeparableFilter( baseFunction, target, format, type ):
+    """Retrieve 2 1D convolution parameter "kernels" as pixel data"""
+    rowDims = (
+        _get_scalar(glGetConvolutionParameteriv( target, GL_CONVOLUTION_WIDTH )),
+        4,
+    )
+    columnDims = (
+        _get_scalar(glGetConvolutionParameteriv( target, GL_CONVOLUTION_HEIGHT )),
+        4,
+    )
+    arrayType = arrays.GL_CONSTANT_TO_ARRAY_TYPE[
+        images.images.TYPE_TO_ARRAYTYPE.get(type,type)
+    ]
+    row = images.images.SetupPixelRead( format, rowDims, type )
+    column = images.images.SetupPixelRead( format, columnDims, type )
+    baseFunction(
+        target, format, type,
+        ctypes.c_void_p( arrayType.dataPointer(row)),
+        ctypes.c_void_p( arrayType.dataPointer(column)),
+        None # span
+    )
+    return row, column
+@_lazy( glGetColorTable )
+def glGetColorTable( baseFunction, target, format, type ):
+    """Retrieve the current 1D color table as a bitmap"""
+    dims = (
+        glGetColorTableParameteriv(target, GL_COLOR_TABLE_WIDTH),
+        4, # Grr, spec *seems* to say that it's different sizes, but it doesn't really say...
+    )
+    array = images.images.SetupPixelRead( format, dims, type )
+    arrayType = arrays.GL_CONSTANT_TO_ARRAY_TYPE[
+        images.images.TYPE_TO_ARRAYTYPE.get(type,type)
+    ]
+    baseFunction(
+        target, format, type,
+        ctypes.c_void_p( arrayType.dataPointer(array))
+    )
+    return array
+@_lazy( glGetHistogram )
+def glGetHistogram( baseFunction, target, reset, format, type, values=None):
+    """Retrieve current 1D histogram as a 1D bitmap"""
+    if values is None:
+        width = glGetHistogramParameteriv(
+            target,
+            GL_HISTOGRAM_WIDTH,
+        )
+        values = images.images.SetupPixelRead( format, (width,4), type )
+    arrayType = arrays.GL_CONSTANT_TO_ARRAY_TYPE[
+        images.images.TYPE_TO_ARRAYTYPE.get(type,type)
+    ]
+    baseFunction(
+        target, reset, format, type,
+        ctypes.c_void_p( arrayType.dataPointer(values))
+    )
+    return values
+
+@_lazy( glGetMinmax )
+def glGetMinmax( baseFunction, target, reset, format, type, values=None):
+    """Retrieve minimum and maximum values as a 2-element image"""
+    if values is None:
+        width = 2
+        values = images.images.SetupPixelRead( format, (width,4), type )
+    arrayType = arrays.GL_CONSTANT_TO_ARRAY_TYPE[
+        images.images.TYPE_TO_ARRAYTYPE.get(type,type)
+    ]
+    baseFunction(
+        target, reset, format, type,
+        ctypes.c_void_p( arrayType.dataPointer(values))
+    )
+    return values

pyopengl-4.0.0a1/OpenGL/GL/ARB/shader_objects.py

@@ -0,0 +1,302 @@
+'''OpenGL extension ARB.shader_objects
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.ARB.shader_objects to provide a more 
+Python-friendly API
+
+Overview (from the spec)
+	
+	This extension adds API calls that are necessary to manage shader
+	objects and program objects as defined in the OpenGL 2.0 white papers by
+	3Dlabs.
+	
+	The generation of an executable that runs on one of OpenGL's
+	programmable units is modeled to that of developing a typical C/C++
+	application. There are one or more source files, each of which are
+	stored by OpenGL in a shader object. Each shader object (source file)
+	needs to be compiled and attached to a program object. Once all shader
+	objects are compiled successfully, the program object needs to be linked
+	to produce an executable. This executable is part of the program object,
+	and can now be loaded onto the programmable units to make it part of the
+	current OpenGL state. Both the compile and link stages generate a text
+	string that can be queried to get more information. This information
+	could be, but is not limited to, compile errors, link errors,
+	optimization hints, etc. Values for uniform variables, declared in a
+	shader, can be set by the application and used to control a shader's
+	behavior.
+	
+	This extension defines functions for creating shader objects and program
+	objects, for compiling shader objects, for linking program objects, for
+	attaching shader objects to program objects, and for using a program
+	object as part of current state. Functions to load uniform values are
+	also defined. Some house keeping functions, like deleting an object and
+	querying object state, are also provided.
+	
+	Although this extension defines the API for creating shader objects, it
+	does not define any specific types of shader objects. It is assumed that
+	this extension will be implemented along with at least one such
+	additional extension for creating a specific type of OpenGL 2.0 shader
+	(e.g., the ARB_fragment_shader extension or the ARB_vertex_shader
+	extension).
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/ARB/shader_objects.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.GL import _types, _glgets
+from OpenGL.raw.GL.ARB.shader_objects import *
+from OpenGL.raw.GL.ARB.shader_objects import _EXTENSION_NAME
+
+def glInitShaderObjectsARB():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+# INPUT glShaderSourceARB.length size not checked against count
+# INPUT glShaderSourceARB.string size not checked against count
+glShaderSourceARB=wrapper.wrapper(glShaderSourceARB).setInputArraySize(
+    'length', None
+).setInputArraySize(
+    'string', None
+)
+# INPUT glUniform1fvARB.value size not checked against count
+glUniform1fvARB=wrapper.wrapper(glUniform1fvARB).setInputArraySize(
+    'value', None
+)
+# INPUT glUniform2fvARB.value size not checked against count*2
+glUniform2fvARB=wrapper.wrapper(glUniform2fvARB).setInputArraySize(
+    'value', None
+)
+# INPUT glUniform3fvARB.value size not checked against count*3
+glUniform3fvARB=wrapper.wrapper(glUniform3fvARB).setInputArraySize(
+    'value', None
+)
+# INPUT glUniform4fvARB.value size not checked against count*4
+glUniform4fvARB=wrapper.wrapper(glUniform4fvARB).setInputArraySize(
+    'value', None
+)
+# INPUT glUniform1ivARB.value size not checked against count
+glUniform1ivARB=wrapper.wrapper(glUniform1ivARB).setInputArraySize(
+    'value', None
+)
+# INPUT glUniform2ivARB.value size not checked against count*2
+glUniform2ivARB=wrapper.wrapper(glUniform2ivARB).setInputArraySize(
+    'value', None
+)
+# INPUT glUniform3ivARB.value size not checked against count*3
+glUniform3ivARB=wrapper.wrapper(glUniform3ivARB).setInputArraySize(
+    'value', None
+)
+# INPUT glUniform4ivARB.value size not checked against count*4
+glUniform4ivARB=wrapper.wrapper(glUniform4ivARB).setInputArraySize(
+    'value', None
+)
+# INPUT glUniformMatrix2fvARB.value size not checked against count*4
+glUniformMatrix2fvARB=wrapper.wrapper(glUniformMatrix2fvARB).setInputArraySize(
+    'value', None
+)
+# INPUT glUniformMatrix3fvARB.value size not checked against count*9
+glUniformMatrix3fvARB=wrapper.wrapper(glUniformMatrix3fvARB).setInputArraySize(
+    'value', None
+)
+# INPUT glUniformMatrix4fvARB.value size not checked against count*16
+glUniformMatrix4fvARB=wrapper.wrapper(glUniformMatrix4fvARB).setInputArraySize(
+    'value', None
+)
+glGetObjectParameterfvARB=wrapper.wrapper(glGetObjectParameterfvARB).setOutput(
+    'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True
+)
+glGetObjectParameterivARB=wrapper.wrapper(glGetObjectParameterivARB).setOutput(
+    'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True
+)
+glGetInfoLogARB=wrapper.wrapper(glGetInfoLogARB).setOutput(
+    'infoLog',size=lambda x:(x,),pnameArg='maxLength',orPassIn=True
+).setOutput(
+    'length',size=(1,),orPassIn=True
+)
+glGetAttachedObjectsARB=wrapper.wrapper(glGetAttachedObjectsARB).setOutput(
+    'count',size=(1,),orPassIn=True
+).setOutput(
+    'obj',size=lambda x:(x,),pnameArg='maxCount',orPassIn=True
+)
+glGetActiveUniformARB=wrapper.wrapper(glGetActiveUniformARB).setOutput(
+    'length',size=(1,),orPassIn=True
+).setOutput(
+    'name',size=lambda x:(x,),pnameArg='maxLength',orPassIn=True
+).setOutput(
+    'size',size=(1,),orPassIn=True
+).setOutput(
+    'type',size=(1,),orPassIn=True
+)
+# OUTPUT glGetUniformfvARB.params COMPSIZE(programObj, location) 
+# OUTPUT glGetUniformivARB.params COMPSIZE(programObj, location) 
+glGetShaderSourceARB=wrapper.wrapper(glGetShaderSourceARB).setOutput(
+    'length',size=(1,),orPassIn=True
+).setOutput(
+    'source',size=lambda x:(x,),pnameArg='maxLength',orPassIn=True
+)
+### END AUTOGENERATED SECTION
+import OpenGL
+from OpenGL._bytes import bytes, _NULL_8_BYTE, as_8_bit
+from OpenGL.raw.GL import _errors
+from OpenGL.lazywrapper import lazy as _lazy
+from OpenGL import converters, error
+
+GL_INFO_LOG_LENGTH_ARB = constant.Constant('GL_INFO_LOG_LENGTH_ARB', 0x8B84)
+
+glShaderSourceARB = platform.createExtensionFunction(
+    'glShaderSourceARB',
+    dll=platform.PLATFORM.GL,
+    resultType=None,
+    argTypes=(
+        _types.GLhandleARB,
+        _types.GLsizei,
+        ctypes.POINTER(ctypes.c_char_p),
+        arrays.GLintArray,
+    ),
+    doc='glShaderSourceARB( GLhandleARB(shaderObj), [bytes(string),...] ) -> None',
+    argNames=(
+        'shaderObj',
+        'count',
+        'string',
+        'length',
+    ),
+    extension=_EXTENSION_NAME,
+)
+conv = converters.StringLengths(name='string')
+glShaderSourceARB = (
+    wrapper.wrapper(glShaderSourceARB)
+    .setPyConverter(
+        'count'  # number of strings
+    )
+    .setPyConverter(
+        'length'  # lengths of strings
+    )
+    .setPyConverter('string', conv.stringArray)
+    .setCResolver(
+        'string',
+        conv.stringArrayForC,
+    )
+    .setCConverter(
+        'length',
+        conv,
+    )
+    .setCConverter(
+        'count',
+        conv.totalCount,
+    )
+)
+try:
+    del conv
+except NameError as err:
+    pass
+
+
+def _afterCheck(key):
+    """Generate an error-checking function for compilation operations"""
+
+    def GLSLCheckError(result, baseOperation=None, cArguments=None, *args):
+        result = _errors._error_checker.glCheckError(
+            result, baseOperation, cArguments, *args
+        )
+        status = glGetObjectParameterivARB(cArguments[0], key)
+        if not status:
+            raise error.GLError(
+                result=result,
+                baseOperation=baseOperation,
+                cArguments=cArguments,
+                description=glGetInfoLogARB(cArguments[0]),
+            )
+        return result
+
+    return GLSLCheckError
+
+
+if OpenGL.ERROR_CHECKING:
+    glCompileShaderARB.errcheck = _afterCheck(GL_OBJECT_COMPILE_STATUS_ARB)
+if OpenGL.ERROR_CHECKING:
+    glLinkProgramARB.errcheck = _afterCheck(GL_OBJECT_LINK_STATUS_ARB)
+## Not sure why, but these give invalid operation :(
+##if glValidateProgramARB and OpenGL.ERROR_CHECKING:
+##	glValidateProgramARB.errcheck = _afterCheck( GL_OBJECT_VALIDATE_STATUS_ARB )
+
+
+@_lazy(glGetInfoLogARB)
+def glGetInfoLogARB(baseOperation, obj):
+    """Retrieve the program/shader's error messages as a Python string
+
+    returns string which is '' if no message
+    """
+    length = int(glGetObjectParameterivARB(obj, GL_INFO_LOG_LENGTH_ARB))
+    if length > 0:
+        log = ctypes.create_string_buffer(length)
+        baseOperation(obj, length, None, log)
+        return log.value.strip(_NULL_8_BYTE)  # null-termination
+    return ''
+
+
+@_lazy(glGetAttachedObjectsARB)
+def glGetAttachedObjectsARB(baseOperation, obj):
+    """Retrieve the attached objects as an array of GLhandleARB instances"""
+    length = glGetObjectParameterivARB(obj, GL_OBJECT_ATTACHED_OBJECTS_ARB)
+    if length > 0:
+        storage = arrays.GLuintArray.zeros((length,))
+        baseOperation(obj, length, None, storage)
+        return storage
+    return arrays.GLuintArray.zeros((0,))
+
+
+@_lazy(glGetShaderSourceARB)
+def glGetShaderSourceARB(baseOperation, obj):
+    """Retrieve the program/shader's source code as a Python string
+
+    returns string which is '' if no source code
+    """
+    length = int(glGetObjectParameterivARB(obj, GL_OBJECT_SHADER_SOURCE_LENGTH_ARB))
+    if length > 0:
+        source = ctypes.create_string_buffer(length)
+        baseOperation(obj, length, None, source)
+        return source.value.strip(_NULL_8_BYTE)  # null-termination
+    return ''
+
+
+@_lazy(glGetActiveUniformARB)
+def glGetActiveUniformARB(baseOperation, program, index, bufSize=None):
+    """Retrieve the name, size and type of the uniform of the index in the program"""
+    max_index = int(glGetObjectParameterivARB(program, GL_OBJECT_ACTIVE_UNIFORMS_ARB))
+    if bufSize is None:
+        bufSize = int(
+            glGetObjectParameterivARB(program, GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB)
+        )
+    if index < max_index and index >= 0:
+        length, name, size, type = baseOperation(program, index, bufSize)
+        if hasattr(name, 'tobytes'):
+            name = name.tobytes().rstrip(b'\000')
+        elif hasattr(name, 'tostring'):
+            name = name.tostring().rstrip(b'\000')
+        elif hasattr(name, 'value'):
+            name = name.value
+        elif isinstance(name, ctypes.Array):
+            # no-numpy backend: name is a raw GLchar ctypes array
+            name = bytes(name).rstrip(b'\000')
+        return name, size, type
+    raise IndexError(
+        'Index %s out of range 0 to %i'
+        % (
+            index,
+            max_index - 1,
+        )
+    )
+
+
+@_lazy(glGetUniformLocationARB)
+def glGetUniformLocationARB(baseOperation, program, name):
+    """Check that name is a string with a null byte at the end of it"""
+    if not name:
+        raise ValueError("""Non-null name required""")
+    name = as_8_bit(name)
+    if name[-1] != _NULL_8_BYTE:
+        name = name + _NULL_8_BYTE
+    return baseOperation(program, name)

pyopengl-4.0.0a1/OpenGL/GL/ARB/shading_language_420pack.py

@@ -0,0 +1,65 @@
+'''OpenGL extension ARB.shading_language_420pack
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.ARB.shading_language_420pack to provide a more 
+Python-friendly API
+
+Overview (from the spec)
+	
+	This is a language feature only extension formed from changes made
+	to version 4.20 of GLSL.  It includes:
+	
+	* Add line-continuation using '\\', as in C++.
+	
+	* Change from ASCII to UTF-8 for the language character set and also 
+	  allow any characters inside comments.
+	
+	* Allow implicit conversions of return values to the declared type of 
+	  the function.
+	
+	* The *const* keyword can be used to declare variables within a function 
+	  body with initializer expressions that are not constant expressions.
+	
+	* Qualifiers on variable declarations no longer have to follow a strict 
+	  order. The layout qualifier can be used multiple times, and multiple 
+	  parameter qualifiers can be used.  However, this is not as
+	  straightforward as saying declarations have arbitrary lists of 
+	  initializers.  Typically, one qualifier from each class of qualifiers
+	  is allowed, so care is now taken to classify them and say so.  Then, 
+	  of these, order restrictions are removed.
+	
+	* Add layout qualifier identifier "binding" to bind the location of a
+	  uniform block.  This requires version 1.4 of GLSL.  If this extension
+	  is used with an earlier version than 1.4, this feature is not present.
+	
+	* Add layout qualifier identifier "binding" to bind units to sampler 
+	  and image variable declarations.
+	
+	* Add C-style curly brace initializer lists syntax for initializers. 
+	  Full initialization of aggregates is required when these are used.
+	
+	* Allow ".length()" to be applied to vectors and matrices, returning 
+	  the number of components or columns.
+	
+	* Allow swizzle operations on scalars.
+	
+	* Built-in constants for gl_MinProgramTexelOffset and 
+	  gl_MaxProgramTexelOffset.
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/ARB/shading_language_420pack.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.GL import _types, _glgets
+from OpenGL.raw.GL.ARB.shading_language_420pack import *
+from OpenGL.raw.GL.ARB.shading_language_420pack import _EXTENSION_NAME
+
+def glInitShadingLanguage420PackARB():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+
+### END AUTOGENERATED SECTION