Initial import from the monolithic Qt.

This is the beginning of revision history for this module. If you
want to look at revision history older than this, please refer to the
Qt Git wiki for how to use Git history grafting. At the time of
writing, this wiki is located here:

http://qt.gitorious.org/qt/pages/GitIntroductionWithQt

If you have already performed the grafting and you don't see any
history beyond this commit, try running "git log" with the "--follow"
argument.

Branched from the monolithic repo, Qt master branch, at commit
896db169ea224deb96c59ce8af800d019de63f12

1 files changed, 3354 insertions, 0 deletions

diff --git a/src/opengl/qglshaderprogram.cpp b/src/opengl/qglshaderprogram.cpp
new file mode 100644
index 0000000000..4598bffabb
--- /dev/null
+++ b/src/opengl/qglshaderprogram.cpp
@@ -0,0 +1,3354 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtOpenGL module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qglshaderprogram.h"
+#include "qglextensions_p.h"
+#include "qgl_p.h"
+#include <QtCore/private/qobject_p.h>
+#include <QtCore/qdebug.h>
+#include <QtCore/qfile.h>
+#include <QtCore/qvarlengtharray.h>
+#include <QtCore/qvector.h>
+
+QT_BEGIN_NAMESPACE
+
+#if !defined(QT_OPENGL_ES_1)
+
+/*!
+    \class QGLShaderProgram
+    \brief The QGLShaderProgram class allows OpenGL shader programs to be linked and used.
+    \since 4.6
+    \ingroup painting-3D
+
+    \section1 Introduction
+
+    This class supports shader programs written in the OpenGL Shading
+    Language (GLSL) and in the OpenGL/ES Shading Language (GLSL/ES).
+
+    QGLShader and QGLShaderProgram shelter the programmer from the details of
+    compiling and linking vertex and fragment shaders.
+
+    The following example creates a vertex shader program using the
+    supplied source \c{code}.  Once compiled and linked, the shader
+    program is activated in the current QGLContext by calling
+    QGLShaderProgram::bind():
+
+    \snippet doc/src/snippets/code/src_opengl_qglshaderprogram.cpp 0
+
+    \section1 Writing portable shaders
+
+    Shader programs can be difficult to reuse across OpenGL implementations
+    because of varying levels of support for standard vertex attributes and
+    uniform variables.  In particular, GLSL/ES lacks all of the
+    standard variables that are present on desktop OpenGL systems:
+    \c{gl_Vertex}, \c{gl_Normal}, \c{gl_Color}, and so on.  Desktop OpenGL
+    lacks the variable qualifiers \c{highp}, \c{mediump}, and \c{lowp}.
+
+    The QGLShaderProgram class makes the process of writing portable shaders
+    easier by prefixing all shader programs with the following lines on
+    desktop OpenGL:
+
+    \code
+    #define highp
+    #define mediump
+    #define lowp
+    \endcode
+
+    This makes it possible to run most GLSL/ES shader programs
+    on desktop systems.  The programmer should restrict themselves
+    to just features that are present in GLSL/ES, and avoid
+    standard variable names that only work on the desktop.
+
+    \section1 Simple shader example
+
+    \snippet doc/src/snippets/code/src_opengl_qglshaderprogram.cpp 1
+
+    With the above shader program active, we can draw a green triangle
+    as follows:
+
+    \snippet doc/src/snippets/code/src_opengl_qglshaderprogram.cpp 2
+
+    \section1 Binary shaders and programs
+
+    Binary shaders may be specified using \c{glShaderBinary()} on
+    the return value from QGLShader::shaderId().  The QGLShader instance
+    containing the binary can then be added to the shader program with
+    addShader() and linked in the usual fashion with link().
+
+    Binary programs may be specified using \c{glProgramBinaryOES()}
+    on the return value from programId().  Then the application should
+    call link(), which will notice that the program has already been
+    specified and linked, allowing other operations to be performed
+    on the shader program.
+
+    \sa QGLShader
+*/
+
+/*!
+    \class QGLShader
+    \brief The QGLShader class allows OpenGL shaders to be compiled.
+    \since 4.6
+    \ingroup painting-3D
+
+    This class supports shaders written in the OpenGL Shading Language (GLSL)
+    and in the OpenGL/ES Shading Language (GLSL/ES).
+
+    QGLShader and QGLShaderProgram shelter the programmer from the details of
+    compiling and linking vertex and fragment shaders.
+
+    \sa QGLShaderProgram
+*/
+
+/*!
+    \enum QGLShader::ShaderTypeBit
+    This enum specifies the type of QGLShader that is being created.
+
+    \value Vertex Vertex shader written in the OpenGL Shading Language (GLSL).
+    \value Fragment Fragment shader written in the OpenGL Shading Language (GLSL).
+    \value Geometry Geometry shaders written in the OpenGL Shading
+           Language (GLSL), based on the GL_EXT_geometry_shader4 extension.
+*/
+
+#ifndef GL_FRAGMENT_SHADER
+#define GL_FRAGMENT_SHADER 0x8B30
+#endif
+#ifndef GL_VERTEX_SHADER
+#define GL_VERTEX_SHADER 0x8B31
+#endif
+#ifndef GL_COMPILE_STATUS
+#define GL_COMPILE_STATUS 0x8B81
+#endif
+#ifndef GL_LINK_STATUS
+#define GL_LINK_STATUS 0x8B82
+#endif
+#ifndef GL_INFO_LOG_LENGTH
+#define GL_INFO_LOG_LENGTH 0x8B84
+#endif
+#ifndef GL_ACTIVE_UNIFORMS
+#define GL_ACTIVE_UNIFORMS 0x8B86
+#endif
+#ifndef GL_ACTIVE_UNIFORM_MAX_LENGTH
+#define GL_ACTIVE_UNIFORM_MAX_LENGTH 0x8B87
+#endif
+#ifndef GL_ACTIVE_ATTRIBUTES
+#define GL_ACTIVE_ATTRIBUTES 0x8B89
+#endif
+#ifndef GL_ACTIVE_ATTRIBUTE_MAX_LENGTH
+#define GL_ACTIVE_ATTRIBUTE_MAX_LENGTH 0x8B8A
+#endif
+#ifndef GL_CURRENT_VERTEX_ATTRIB
+#define GL_CURRENT_VERTEX_ATTRIB 0x8626
+#endif
+#ifndef GL_SHADER_SOURCE_LENGTH
+#define GL_SHADER_SOURCE_LENGTH 0x8B88
+#endif
+#ifndef GL_SHADER_BINARY_FORMATS
+#define GL_SHADER_BINARY_FORMATS          0x8DF8
+#endif
+#ifndef GL_NUM_SHADER_BINARY_FORMATS
+#define GL_NUM_SHADER_BINARY_FORMATS      0x8DF9
+#endif
+
+class QGLShaderPrivate : public QObjectPrivate
+{
+    Q_DECLARE_PUBLIC(QGLShader)
+public:
+    QGLShaderPrivate(const QGLContext *context, QGLShader::ShaderType type)
+        : shaderGuard(context)
+        , shaderType(type)
+        , compiled(false)
+    {
+    }
+    ~QGLShaderPrivate();
+
+    QGLSharedResourceGuard shaderGuard;
+    QGLShader::ShaderType shaderType;
+    bool compiled;
+    QString log;
+
+    bool create();
+    bool compile(QGLShader *q);
+    void deleteShader();
+};
+
+#define ctx shaderGuard.context()
+
+QGLShaderPrivate::~QGLShaderPrivate()
+{
+    if (shaderGuard.id()) {
+        QGLShareContextScope scope(shaderGuard.context());
+        glDeleteShader(shaderGuard.id());
+    }
+}
+
+bool QGLShaderPrivate::create()
+{
+    const QGLContext *context = shaderGuard.context();
+    if (!context)
+        return false;
+    if (qt_resolve_glsl_extensions(const_cast<QGLContext *>(context))) {
+        GLuint shader;
+        if (shaderType == QGLShader::Vertex)
+            shader = glCreateShader(GL_VERTEX_SHADER);
+        else if (shaderType == QGLShader::Geometry)
+            shader = glCreateShader(GL_GEOMETRY_SHADER_EXT);
+        else
+            shader = glCreateShader(GL_FRAGMENT_SHADER);
+        if (!shader) {
+            qWarning() << "QGLShader: could not create shader";
+            return false;
+        }
+        shaderGuard.setId(shader);
+        return true;
+    } else {
+        return false;
+    }
+}
+
+bool QGLShaderPrivate::compile(QGLShader *q)
+{
+    GLuint shader = shaderGuard.id();
+    if (!shader)
+        return false;
+    glCompileShader(shader);
+    GLint value = 0;
+    glGetShaderiv(shader, GL_COMPILE_STATUS, &value);
+    compiled = (value != 0);
+    value = 0;
+    glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &value);
+    if (!compiled && value > 1) {
+        char *logbuf = new char [value];
+        GLint len;
+        glGetShaderInfoLog(shader, value, &len, logbuf);
+        log = QString::fromLatin1(logbuf);
+        QString name = q->objectName();
+
+        const char *types[] = {
+            "Fragment",
+            "Vertex",
+            "Geometry",
+            ""
+        };
+
+        const char *type = types[3];
+        if (shaderType == QGLShader::Fragment)
+            type = types[0];
+        else if (shaderType == QGLShader::Vertex)
+            type = types[1];
+        else if (shaderType == QGLShader::Geometry)
+            type = types[2];
+
+        if (name.isEmpty())
+            qWarning("QGLShader::compile(%s): %s", type, qPrintable(log));
+        else
+            qWarning("QGLShader::compile(%s)[%s]: %s", type, qPrintable(name), qPrintable(log));
+
+        delete [] logbuf;
+    }
+    return compiled;
+}
+
+void QGLShaderPrivate::deleteShader()
+{
+    if (shaderGuard.id()) {
+        glDeleteShader(shaderGuard.id());
+        shaderGuard.setId(0);
+    }
+}
+
+#undef ctx
+#define ctx d->shaderGuard.context()
+
+/*!
+    Constructs a new QGLShader object of the specified \a type
+    and attaches it to \a parent.  If shader programs are not supported,
+    QGLShaderProgram::hasOpenGLShaderPrograms() will return false.
+
+    This constructor is normally followed by a call to compileSourceCode()
+    or compileSourceFile().
+
+    The shader will be associated with the current QGLContext.
+
+    \sa compileSourceCode(), compileSourceFile()
+*/
+QGLShader::QGLShader(QGLShader::ShaderType type, QObject *parent)
+    : QObject(*new QGLShaderPrivate(QGLContext::currentContext(), type), parent)
+{
+    Q_D(QGLShader);
+    d->create();
+}
+
+/*!
+    Constructs a new QGLShader object of the specified \a type
+    and attaches it to \a parent.  If shader programs are not supported,
+    then QGLShaderProgram::hasOpenGLShaderPrograms() will return false.
+
+    This constructor is normally followed by a call to compileSourceCode()
+    or compileSourceFile().
+
+    The shader will be associated with \a context.
+
+    \sa compileSourceCode(), compileSourceFile()
+*/
+QGLShader::QGLShader(QGLShader::ShaderType type, const QGLContext *context, QObject *parent)
+    : QObject(*new QGLShaderPrivate(context ? context : QGLContext::currentContext(), type), parent)
+{
+    Q_D(QGLShader);
+#ifndef QT_NO_DEBUG
+    if (context && !QGLContext::areSharing(context, QGLContext::currentContext())) {
+        qWarning("QGLShader::QGLShader: \'context\' must be the current context or sharing with it.");
+        return;
+    }
+#endif
+    d->create();
+}
+
+/*!
+    Deletes this shader.  If the shader has been attached to a
+    QGLShaderProgram object, then the actual shader will stay around
+    until the QGLShaderProgram is destroyed.
+*/
+QGLShader::~QGLShader()
+{
+}
+
+/*!
+    Returns the type of this shader.
+*/
+QGLShader::ShaderType QGLShader::shaderType() const
+{
+    Q_D(const QGLShader);
+    return d->shaderType;
+}
+
+// The precision qualifiers are useful on OpenGL/ES systems,
+// but usually not present on desktop systems.  Define the
+// keywords to empty strings on desktop systems.
+#ifndef QT_OPENGL_ES
+#define QGL_DEFINE_QUALIFIERS 1
+static const char qualifierDefines[] =
+    "#define lowp\n"
+    "#define mediump\n"
+    "#define highp\n";
+#endif
+
+// The "highp" qualifier doesn't exist in fragment shaders
+// on all ES platforms.  When it doesn't exist, use "mediump".
+#ifdef QT_OPENGL_ES
+#define QGL_REDEFINE_HIGHP 1
+static const char redefineHighp[] =
+    "#ifndef GL_FRAGMENT_PRECISION_HIGH\n"
+    "#define highp mediump\n"
+    "#endif\n";
+#endif
+
+/*!
+    Sets the \a source code for this shader and compiles it.
+    Returns true if the source was successfully compiled, false otherwise.
+
+    \sa compileSourceFile()
+*/
+bool QGLShader::compileSourceCode(const char *source)
+{
+    Q_D(QGLShader);
+    if (d->shaderGuard.id()) {
+        QVarLengthArray<const char *, 4> src;
+        QVarLengthArray<GLint, 4> srclen;
+        int headerLen = 0;
+        while (source && source[headerLen] == '#') {
+            // Skip #version and #extension directives at the start of
+            // the shader code.  We need to insert the qualifierDefines
+            // and redefineHighp just after them.
+            if (qstrncmp(source + headerLen, "#version", 8) != 0 &&
+                    qstrncmp(source + headerLen, "#extension", 10) != 0) {
+                break;
+            }
+            while (source[headerLen] != '\0' && source[headerLen] != '\n')
+                ++headerLen;
+            if (source[headerLen] == '\n')
+                ++headerLen;
+        }
+        if (headerLen > 0) {
+            src.append(source);
+            srclen.append(GLint(headerLen));
+        }
+#ifdef QGL_DEFINE_QUALIFIERS
+        src.append(qualifierDefines);
+        srclen.append(GLint(sizeof(qualifierDefines) - 1));
+#endif
+#ifdef QGL_REDEFINE_HIGHP
+        if (d->shaderType == Fragment) {
+            src.append(redefineHighp);
+            srclen.append(GLint(sizeof(redefineHighp) - 1));
+        }
+#endif
+        src.append(source + headerLen);
+        srclen.append(GLint(qstrlen(source + headerLen)));
+        glShaderSource(d->shaderGuard.id(), src.size(), src.data(), srclen.data());
+        return d->compile(this);
+    } else {
+        return false;
+    }
+}
+
+/*!
+    \overload
+
+    Sets the \a source code for this shader and compiles it.
+    Returns true if the source was successfully compiled, false otherwise.
+
+    \sa compileSourceFile()
+*/
+bool QGLShader::compileSourceCode(const QByteArray& source)
+{
+    return compileSourceCode(source.constData());
+}
+
+/*!
+    \overload
+
+    Sets the \a source code for this shader and compiles it.
+    Returns true if the source was successfully compiled, false otherwise.
+
+    \sa compileSourceFile()
+*/
+bool QGLShader::compileSourceCode(const QString& source)
+{
+    return compileSourceCode(source.toLatin1().constData());
+}
+
+/*!
+    Sets the source code for this shader to the contents of \a fileName
+    and compiles it.  Returns true if the file could be opened and the
+    source compiled, false otherwise.
+
+    \sa compileSourceCode()
+*/
+bool QGLShader::compileSourceFile(const QString& fileName)
+{
+    QFile file(fileName);
+    if (!file.open(QFile::ReadOnly)) {
+        qWarning() << "QGLShader: Unable to open file" << fileName;
+        return false;
+    }
+
+    QByteArray contents = file.readAll();
+    return compileSourceCode(contents.constData());
+}
+
+/*!
+    Returns the source code for this shader.
+
+    \sa compileSourceCode()
+*/
+QByteArray QGLShader::sourceCode() const
+{
+    Q_D(const QGLShader);
+    GLuint shader = d->shaderGuard.id();
+    if (!shader)
+        return QByteArray();
+    GLint size = 0;
+    glGetShaderiv(shader, GL_SHADER_SOURCE_LENGTH, &size);
+    if (size <= 0)
+        return QByteArray();
+    GLint len = 0;
+    char *source = new char [size];
+    glGetShaderSource(shader, size, &len, source);
+    QByteArray src(source);
+    delete [] source;
+    return src;
+}
+
+/*!
+    Returns true if this shader has been compiled; false otherwise.
+
+    \sa compileSourceCode(), compileSourceFile()
+*/
+bool QGLShader::isCompiled() const
+{
+    Q_D(const QGLShader);
+    return d->compiled;
+}
+
+/*!
+    Returns the errors and warnings that occurred during the last compile.
+
+    \sa compileSourceCode(), compileSourceFile()
+*/
+QString QGLShader::log() const
+{
+    Q_D(const QGLShader);
+    return d->log;
+}
+
+/*!
+    Returns the OpenGL identifier associated with this shader.
+
+    \sa QGLShaderProgram::programId()
+*/
+GLuint QGLShader::shaderId() const
+{
+    Q_D(const QGLShader);
+    return d->shaderGuard.id();
+}
+
+
+
+
+
+#undef ctx
+#define ctx programGuard.context()
+
+class QGLShaderProgramPrivate : public QObjectPrivate
+{
+    Q_DECLARE_PUBLIC(QGLShaderProgram)
+public:
+    QGLShaderProgramPrivate(const QGLContext *context)
+        : programGuard(context)
+        , linked(false)
+        , inited(false)
+        , removingShaders(false)
+        , geometryVertexCount(64)
+        , geometryInputType(0)
+        , geometryOutputType(0)
+    {
+    }
+    ~QGLShaderProgramPrivate();
+
+    QGLSharedResourceGuard programGuard;
+    bool linked;
+    bool inited;
+    bool removingShaders;
+
+    int geometryVertexCount;
+    GLenum geometryInputType;
+    GLenum geometryOutputType;
+
+    QString log;
+    QList<QGLShader *> shaders;
+    QList<QGLShader *> anonShaders;
+
+    bool hasShader(QGLShader::ShaderType type) const;
+};
+
+QGLShaderProgramPrivate::~QGLShaderProgramPrivate()
+{
+    if (programGuard.id()) {
+        QGLShareContextScope scope(programGuard.context());
+        glDeleteProgram(programGuard.id());
+    }
+}
+
+bool QGLShaderProgramPrivate::hasShader(QGLShader::ShaderType type) const
+{
+    foreach (QGLShader *shader, shaders) {
+        if (shader->shaderType() == type)
+            return true;
+    }
+    return false;
+}
+
+#undef ctx
+#define ctx d->programGuard.context()
+
+/*!
+    Constructs a new shader program and attaches it to \a parent.
+    The program will be invalid until addShader() is called.
+
+    The shader program will be associated with the current QGLContext.
+
+    \sa addShader()
+*/
+QGLShaderProgram::QGLShaderProgram(QObject *parent)
+    : QObject(*new QGLShaderProgramPrivate(QGLContext::currentContext()), parent)
+{
+}
+
+/*!
+    Constructs a new shader program and attaches it to \a parent.
+    The program will be invalid until addShader() is called.
+
+    The shader program will be associated with \a context.
+
+    \sa addShader()
+*/
+QGLShaderProgram::QGLShaderProgram(const QGLContext *context, QObject *parent)
+    : QObject(*new QGLShaderProgramPrivate(context), parent)
+{
+}
+
+/*!
+    Deletes this shader program.
+*/
+QGLShaderProgram::~QGLShaderProgram()
+{
+}
+
+bool QGLShaderProgram::init()
+{
+    Q_D(QGLShaderProgram);
+    if (d->programGuard.id() || d->inited)
+        return true;
+    d->inited = true;
+    const QGLContext *context = d->programGuard.context();
+    if (!context) {
+        context = QGLContext::currentContext();
+        d->programGuard.setContext(context);
+    }
+
+    if (!context)
+        return false;
+    if (qt_resolve_glsl_extensions(const_cast<QGLContext *>(context))) {
+        GLuint program = glCreateProgram();
+        if (!program) {
+            qWarning() << "QGLShaderProgram: could not create shader program";
+            return false;
+        }
+        d->programGuard.setId(program);
+        return true;
+    } else {
+        qWarning() << "QGLShaderProgram: shader programs are not supported";
+        return false;
+    }
+}
+
+/*!
+    Adds a compiled \a shader to this shader program.  Returns true
+    if the shader could be added, or false otherwise.
+
+    Ownership of the \a shader object remains with the caller.
+    It will not be deleted when this QGLShaderProgram instance
+    is deleted.  This allows the caller to add the same shader
+    to multiple shader programs.
+
+    \sa addShaderFromSourceCode(), addShaderFromSourceFile()
+    \sa removeShader(), link(), removeAllShaders()
+*/
+bool QGLShaderProgram::addShader(QGLShader *shader)
+{
+    Q_D(QGLShaderProgram);
+    if (!init())
+        return false;
+    if (d->shaders.contains(shader))
+        return true;    // Already added to this shader program.
+    if (d->programGuard.id() && shader) {
+        if (!QGLContext::areSharing(shader->d_func()->shaderGuard.context(),
+                                    d->programGuard.context())) {
+            qWarning("QGLShaderProgram::addShader: Program and shader are not associated with same context.");
+            return false;
+        }
+        if (!shader->d_func()->shaderGuard.id())
+            return false;
+        glAttachShader(d->programGuard.id(), shader->d_func()->shaderGuard.id());
+        d->linked = false;  // Program needs to be relinked.
+        d->shaders.append(shader);
+        connect(shader, SIGNAL(destroyed()), this, SLOT(shaderDestroyed()));
+        return true;
+    } else {
+        return false;
+    }
+}
+
+/*!
+    Compiles \a source as a shader of the specified \a type and
+    adds it to this shader program.  Returns true if compilation
+    was successful, false otherwise.  The compilation errors
+    and warnings will be made available via log().
+
+    This function is intended to be a short-cut for quickly
+    adding vertex and fragment shaders to a shader program without
+    creating an instance of QGLShader first.
+
+    \sa addShader(), addShaderFromSourceFile()
+    \sa removeShader(), link(), log(), removeAllShaders()
+*/
+bool QGLShaderProgram::addShaderFromSourceCode(QGLShader::ShaderType type, const char *source)
+{
+    Q_D(QGLShaderProgram);
+    if (!init())
+        return false;
+    QGLShader *shader = new QGLShader(type, this);
+    if (!shader->compileSourceCode(source)) {
+        d->log = shader->log();
+        delete shader;
+        return false;
+    }
+    d->anonShaders.append(shader);
+    return addShader(shader);
+}
+
+/*!
+    \overload
+
+    Compiles \a source as a shader of the specified \a type and
+    adds it to this shader program.  Returns true if compilation
+    was successful, false otherwise.  The compilation errors
+    and warnings will be made available via log().
+
+    This function is intended to be a short-cut for quickly
+    adding vertex and fragment shaders to a shader program without
+    creating an instance of QGLShader first.
+
+    \sa addShader(), addShaderFromSourceFile()
+    \sa removeShader(), link(), log(), removeAllShaders()
+*/
+bool QGLShaderProgram::addShaderFromSourceCode(QGLShader::ShaderType type, const QByteArray& source)
+{
+    return addShaderFromSourceCode(type, source.constData());
+}
+
+/*!
+    \overload
+
+    Compiles \a source as a shader of the specified \a type and
+    adds it to this shader program.  Returns true if compilation
+    was successful, false otherwise.  The compilation errors
+    and warnings will be made available via log().
+
+    This function is intended to be a short-cut for quickly
+    adding vertex and fragment shaders to a shader program without
+    creating an instance of QGLShader first.
+
+    \sa addShader(), addShaderFromSourceFile()
+    \sa removeShader(), link(), log(), removeAllShaders()
+*/
+bool QGLShaderProgram::addShaderFromSourceCode(QGLShader::ShaderType type, const QString& source)
+{
+    return addShaderFromSourceCode(type, source.toLatin1().constData());
+}
+
+/*!
+    Compiles the contents of \a fileName as a shader of the specified
+    \a type and adds it to this shader program.  Returns true if
+    compilation was successful, false otherwise.  The compilation errors
+    and warnings will be made available via log().
+
+    This function is intended to be a short-cut for quickly
+    adding vertex and fragment shaders to a shader program without
+    creating an instance of QGLShader first.
+
+    \sa addShader(), addShaderFromSourceCode()
+*/
+bool QGLShaderProgram::addShaderFromSourceFile
+    (QGLShader::ShaderType type, const QString& fileName)
+{
+    Q_D(QGLShaderProgram);
+    if (!init())
+        return false;
+    QGLShader *shader = new QGLShader(type, this);
+    if (!shader->compileSourceFile(fileName)) {
+        d->log = shader->log();
+        delete shader;
+        return false;
+    }
+    d->anonShaders.append(shader);
+    return addShader(shader);
+}
+
+/*!
+    Removes \a shader from this shader program.  The object is not deleted.
+
+    \sa addShader(), link(), removeAllShaders()
+*/
+void QGLShaderProgram::removeShader(QGLShader *shader)
+{
+    Q_D(QGLShaderProgram);
+    if (d->programGuard.id() && shader && shader->d_func()->shaderGuard.id()) {
+        QGLShareContextScope scope(d->programGuard.context());
+        glDetachShader(d->programGuard.id(), shader->d_func()->shaderGuard.id());
+    }
+    d->linked = false;  // Program needs to be relinked.
+    if (shader) {
+        d->shaders.removeAll(shader);
+        d->anonShaders.removeAll(shader);
+        disconnect(shader, SIGNAL(destroyed()), this, SLOT(shaderDestroyed()));
+    }
+}
+
+/*!
+    Returns a list of all shaders that have been added to this shader
+    program using addShader().
+
+    \sa addShader(), removeShader()
+*/
+QList<QGLShader *> QGLShaderProgram::shaders() const
+{
+    Q_D(const QGLShaderProgram);
+    return d->shaders;
+}
+
+/*!
+    Removes all of the shaders that were added to this program previously.
+    The QGLShader objects for the shaders will not be deleted if they
+    were constructed externally.  QGLShader objects that are constructed
+    internally by QGLShaderProgram will be deleted.
+
+    \sa addShader(), removeShader()
+*/
+void QGLShaderProgram::removeAllShaders()
+{
+    Q_D(QGLShaderProgram);
+    d->removingShaders = true;
+    foreach (QGLShader *shader, d->shaders) {
+        if (d->programGuard.id() && shader && shader->d_func()->shaderGuard.id())
+            glDetachShader(d->programGuard.id(), shader->d_func()->shaderGuard.id());
+    }
+    foreach (QGLShader *shader, d->anonShaders) {
+        // Delete shader objects that were created anonymously.
+        delete shader;
+    }
+    d->shaders.clear();
+    d->anonShaders.clear();
+    d->linked = false;  // Program needs to be relinked.
+    d->removingShaders = false;
+}
+
+/*!
+    Links together the shaders that were added to this program with
+    addShader().  Returns true if the link was successful or
+    false otherwise.  If the link failed, the error messages can
+    be retrieved with log().
+
+    Subclasses can override this function to initialize attributes
+    and uniform variables for use in specific shader programs.
+
+    If the shader program was already linked, calling this
+    function again will force it to be re-linked.
+
+    \sa addShader(), log()
+*/
+bool QGLShaderProgram::link()
+{
+    Q_D(QGLShaderProgram);
+    GLuint program = d->programGuard.id();
+    if (!program)
+        return false;
+
+    GLint value;
+    if (d->shaders.isEmpty()) {
+        // If there are no explicit shaders, then it is possible that the
+        // application added a program binary with glProgramBinaryOES(),
+        // or otherwise populated the shaders itself.  Check to see if the
+        // program is already linked and bail out if so.
+        value = 0;
+        glGetProgramiv(program, GL_LINK_STATUS, &value);
+        d->linked = (value != 0);
+        if (d->linked)
+            return true;
+    }
+
+    // Set up the geometry shader parameters
+    if (glProgramParameteriEXT) {
+        foreach (QGLShader *shader, d->shaders) {
+            if (shader->shaderType() & QGLShader::Geometry) {
+                glProgramParameteriEXT(program, GL_GEOMETRY_INPUT_TYPE_EXT,
+                                       d->geometryInputType);
+                glProgramParameteriEXT(program, GL_GEOMETRY_OUTPUT_TYPE_EXT,
+                                       d->geometryOutputType);
+                glProgramParameteriEXT(program, GL_GEOMETRY_VERTICES_OUT_EXT,
+                                       d->geometryVertexCount);
+                break;
+            }
+        }
+    }
+
+    glLinkProgram(program);
+    value = 0;
+    glGetProgramiv(program, GL_LINK_STATUS, &value);
+    d->linked = (value != 0);
+    value = 0;
+    glGetProgramiv(program, GL_INFO_LOG_LENGTH, &value);
+    d->log = QString();
+    if (value > 1) {
+        char *logbuf = new char [value];
+        GLint len;
+        glGetProgramInfoLog(program, value, &len, logbuf);
+        d->log = QString::fromLatin1(logbuf);
+        QString name = objectName();
+        if (name.isEmpty())
+            qWarning() << "QGLShader::link:" << d->log;
+        else
+            qWarning() << "QGLShader::link[" << name << "]:" << d->log;
+        delete [] logbuf;
+    }
+    return d->linked;
+}
+
+/*!
+    Returns true if this shader program has been linked; false otherwise.
+
+    \sa link()
+*/
+bool QGLShaderProgram::isLinked() const
+{
+    Q_D(const QGLShaderProgram);
+    return d->linked;
+}
+
+/*!
+    Returns the errors and warnings that occurred during the last link()
+    or addShader() with explicitly specified source code.
+
+    \sa link()
+*/
+QString QGLShaderProgram::log() const
+{
+    Q_D(const QGLShaderProgram);
+    return d->log;
+}
+
+/*!
+    Binds this shader program to the active QGLContext and makes
+    it the current shader program.  Any previously bound shader program
+    is released.  This is equivalent to calling \c{glUseProgram()} on
+    programId().  Returns true if the program was successfully bound;
+    false otherwise.  If the shader program has not yet been linked,
+    or it needs to be re-linked, this function will call link().
+
+    \sa link(), release()
+*/
+bool QGLShaderProgram::bind()
+{
+    Q_D(QGLShaderProgram);
+    GLuint program = d->programGuard.id();
+    if (!program)
+        return false;
+    if (!d->linked && !link())
+        return false;
+#ifndef QT_NO_DEBUG
+    if (!QGLContext::areSharing(d->programGuard.context(), QGLContext::currentContext())) {
+        qWarning("QGLShaderProgram::bind: program is not valid in the current context.");
+        return false;
+    }
+#endif
+    glUseProgram(program);
+    return true;
+}
+
+#undef ctx
+#define ctx QGLContext::currentContext()
+
+/*!
+    Releases the active shader program from the current QGLContext.
+    This is equivalent to calling \c{glUseProgram(0)}.
+
+    \sa bind()
+*/
+void QGLShaderProgram::release()
+{
+#ifndef QT_NO_DEBUG
+    Q_D(QGLShaderProgram);
+    if (!QGLContext::areSharing(d->programGuard.context(), QGLContext::currentContext()))
+        qWarning("QGLShaderProgram::release: program is not valid in the current context.");
+#endif
+#if defined(QT_OPENGL_ES_2)
+    glUseProgram(0);
+#else
+    if (glUseProgram)
+        glUseProgram(0);
+#endif
+}
+
+#undef ctx
+#define ctx d->programGuard.context()
+
+/*!
+    Returns the OpenGL identifier associated with this shader program.
+
+    \sa QGLShader::shaderId()
+*/
+GLuint QGLShaderProgram::programId() const
+{
+    Q_D(const QGLShaderProgram);
+    GLuint id = d->programGuard.id();
+    if (id)
+        return id;
+
+    // Create the identifier if we don't have one yet.  This is for
+    // applications that want to create the attached shader configuration
+    // themselves, particularly those using program binaries.
+    if (!const_cast<QGLShaderProgram *>(this)->init())
+        return 0;
+    return d->programGuard.id();
+}
+
+/*!
+    Binds the attribute \a name to the specified \a location.  This
+    function can be called before or after the program has been linked.
+    Any attributes that have not been explicitly bound when the program
+    is linked will be assigned locations automatically.
+
+    When this function is called after the program has been linked,
+    the program will need to be relinked for the change to take effect.
+
+    \sa attributeLocation()
+*/
+void QGLShaderProgram::bindAttributeLocation(const char *name, int location)
+{
+    Q_D(QGLShaderProgram);
+    if (!init())
+        return;
+    glBindAttribLocation(d->programGuard.id(), location, name);
+    d->linked = false;  // Program needs to be relinked.
+}
+
+/*!
+    \overload
+
+    Binds the attribute \a name to the specified \a location.  This
+    function can be called before or after the program has been linked.
+    Any attributes that have not been explicitly bound when the program
+    is linked will be assigned locations automatically.
+
+    When this function is called after the program has been linked,
+    the program will need to be relinked for the change to take effect.
+
+    \sa attributeLocation()
+*/
+void QGLShaderProgram::bindAttributeLocation(const QByteArray& name, int location)
+{
+    bindAttributeLocation(name.constData(), location);
+}
+
+/*!
+    \overload
+
+    Binds the attribute \a name to the specified \a location.  This
+    function can be called before or after the program has been linked.
+    Any attributes that have not been explicitly bound when the program
+    is linked will be assigned locations automatically.
+
+    When this function is called after the program has been linked,
+    the program will need to be relinked for the change to take effect.
+
+    \sa attributeLocation()
+*/
+void QGLShaderProgram::bindAttributeLocation(const QString& name, int location)
+{
+    bindAttributeLocation(name.toLatin1().constData(), location);
+}
+
+/*!
+    Returns the location of the attribute \a name within this shader
+    program's parameter list.  Returns -1 if \a name is not a valid
+    attribute for this shader program.
+
+    \sa uniformLocation(), bindAttributeLocation()
+*/
+int QGLShaderProgram::attributeLocation(const char *name) const
+{
+    Q_D(const QGLShaderProgram);
+    if (d->linked) {
+        return glGetAttribLocation(d->programGuard.id(), name);
+    } else {
+        qWarning() << "QGLShaderProgram::attributeLocation(" << name
+                   << "): shader program is not linked";
+        return -1;
+    }
+}
+
+/*!
+    \overload
+
+    Returns the location of the attribute \a name within this shader
+    program's parameter list.  Returns -1 if \a name is not a valid
+    attribute for this shader program.
+
+    \sa uniformLocation(), bindAttributeLocation()
+*/
+int QGLShaderProgram::attributeLocation(const QByteArray& name) const
+{
+    return attributeLocation(name.constData());
+}
+
+/*!
+    \overload
+
+    Returns the location of the attribute \a name within this shader
+    program's parameter list.  Returns -1 if \a name is not a valid
+    attribute for this shader program.
+
+    \sa uniformLocation(), bindAttributeLocation()
+*/
+int QGLShaderProgram::attributeLocation(const QString& name) const
+{
+    return attributeLocation(name.toLatin1().constData());
+}
+
+/*!
+    Sets the attribute at \a location in the current context to \a value.
+
+    \sa setUniformValue()
+*/
+void QGLShaderProgram::setAttributeValue(int location, GLfloat value)
+{
+    Q_D(QGLShaderProgram);
+    Q_UNUSED(d);
+    if (location != -1)
+        glVertexAttrib1fv(location, &value);
+}
+
+/*!
+    \overload
+
+    Sets the attribute called \a name in the current context to \a value.
+
+    \sa setUniformValue()
+*/
+void QGLShaderProgram::setAttributeValue(const char *name, GLfloat value)
+{
+    setAttributeValue(attributeLocation(name), value);
+}
+
+/*!
+    Sets the attribute at \a location in the current context to
+    the 2D vector (\a x, \a y).
+
+    \sa setUniformValue()
+*/
+void QGLShaderProgram::setAttributeValue(int location, GLfloat x, GLfloat y)
+{
+    Q_D(QGLShaderProgram);
+    Q_UNUSED(d);
+    if (location != -1) {
+        GLfloat values[2] = {x, y};
+        glVertexAttrib2fv(location, values);
+    }
+}
+
+/*!
+    \overload
+
+    Sets the attribute called \a name in the current context to
+    the 2D vector (\a x, \a y).
+
+    \sa setUniformValue()
+*/
+void QGLShaderProgram::setAttributeValue(const char *name, GLfloat x, GLfloat y)
+{
+    setAttributeValue(attributeLocation(name), x, y);
+}
+
+/*!
+    Sets the attribute at \a location in the current context to
+    the 3D vector (\a x, \a y, \a z).
+
+    \sa setUniformValue()
+*/
+void QGLShaderProgram::setAttributeValue
+        (int location, GLfloat x, GLfloat y, GLfloat z)
+{
+    Q_D(QGLShaderProgram);
+    Q_UNUSED(d);
+    if (location != -1) {
+        GLfloat values[3] = {x, y, z};
+        glVertexAttrib3fv(location, values);
+    }
+}
+
+/*!
+    \overload
+
+    Sets the attribute called \a name in the current context to
+    the 3D vector (\a x, \a y, \a z).
+
+    \sa setUniformValue()
+*/
+void QGLShaderProgram::setAttributeValue
+        (const char *name, GLfloat x, GLfloat y, GLfloat z)
+{
+    setAttributeValue(attributeLocation(name), x, y, z);
+}
+
+/*!
+    Sets the attribute at \a location in the current context to
+    the 4D vector (\a x, \a y, \a z, \a w).
+
+    \sa setUniformValue()
+*/
+void QGLShaderProgram::setAttributeValue
+        (int location, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+{
+    Q_D(QGLShaderProgram);
+    Q_UNUSED(d);
+    if (location != -1) {
+        GLfloat values[4] = {x, y, z, w};
+        glVertexAttrib4fv(location, values);
+    }
+}
+
+/*!
+    \overload
+
+    Sets the attribute called \a name in the current context to
+    the 4D vector (\a x, \a y, \a z, \a w).
+
+    \sa setUniformValue()
+*/
+void QGLShaderProgram::setAttributeValue
+        (const char *name, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+{
+    setAttributeValue(attributeLocation(name), x, y, z, w);
+}
+
+/*!
+    Sets the attribute at \a location in the current context to \a value.
+
+    \sa setUniformValue()
+*/
+void QGLShaderProgram::setAttributeValue(int location, const QVector2D& value)
+{
+    Q_D(QGLShaderProgram);
+    Q_UNUSED(d);
+    if (location != -1)
+        glVertexAttrib2fv(location, reinterpret_cast<const GLfloat *>(&value));
+}
+
+/*!
+    \overload
+
+    Sets the attribute called \a name in the current context to \a value.
+
+    \sa setUniformValue()
+*/
+void QGLShaderProgram::setAttributeValue(const char *name, const QVector2D& value)
+{
+    setAttributeValue(attributeLocation(name), value);
+}
+
+/*!
+    Sets the attribute at \a location in the current context to \a value.
+
+    \sa setUniformValue()
+*/
+void QGLShaderProgram::setAttributeValue(int location, const QVector3D& value)
+{
+    Q_D(QGLShaderProgram);
+    Q_UNUSED(d);
+    if (location != -1)
+        glVertexAttrib3fv(location, reinterpret_cast<const GLfloat *>(&value));
+}
+
+/*!
+    \overload
+
+    Sets the attribute called \a name in the current context to \a value.
+
+    \sa setUniformValue()
+*/
+void QGLShaderProgram::setAttributeValue(const char *name, const QVector3D& value)
+{
+    setAttributeValue(attributeLocation(name), value);
+}
+
+/*!
+    Sets the attribute at \a location in the current context to \a value.
+
+    \sa setUniformValue()
+*/
+void QGLShaderProgram::setAttributeValue(int location, const QVector4D& value)
+{
+    Q_D(QGLShaderProgram);
+    Q_UNUSED(d);
+    if (location != -1)
+        glVertexAttrib4fv(location, reinterpret_cast<const GLfloat *>(&value));
+}
+
+/*!
+    \overload
+
+    Sets the attribute called \a name in the current context to \a value.
+
+    \sa setUniformValue()
+*/
+void QGLShaderProgram::setAttributeValue(const char *name, const QVector4D& value)
+{
+    setAttributeValue(attributeLocation(name), value);
+}
+
+/*!
+    Sets the attribute at \a location in the current context to \a value.
+
+    \sa setUniformValue()
+*/
+void QGLShaderProgram::setAttributeValue(int location, const QColor& value)
+{
+    Q_D(QGLShaderProgram);
+    Q_UNUSED(d);
+    if (location != -1) {
+        GLfloat values[4] = {GLfloat(value.redF()), GLfloat(value.greenF()),
+                             GLfloat(value.blueF()), GLfloat(value.alphaF())};
+        glVertexAttrib4fv(location, values);
+    }
+}
+
+/*!
+    \overload
+
+    Sets the attribute called \a name in the current context to \a value.
+
+    \sa setUniformValue()
+*/
+void QGLShaderProgram::setAttributeValue(const char *name, const QColor& value)
+{
+    setAttributeValue(attributeLocation(name), value);
+}
+
+/*!
+    Sets the attribute at \a location in the current context to the
+    contents of \a values, which contains \a columns elements, each
+    consisting of \a rows elements.  The \a rows value should be
+    1, 2, 3, or 4.  This function is typically used to set matrix
+    values and column vectors.
+
+    \sa setUniformValue()
+*/
+void QGLShaderProgram::setAttributeValue
+    (int location, const GLfloat *values, int columns, int rows)
+{
+    Q_D(QGLShaderProgram);
+    Q_UNUSED(d);
+    if (rows < 1 || rows > 4) {
+        qWarning() << "QGLShaderProgram::setAttributeValue: rows" << rows << "not supported";
+        return;
+    }
+    if (location != -1) {
+        while (columns-- > 0) {
+            if (rows == 1)
+                glVertexAttrib1fv(location, values);
+            else if (rows == 2)
+                glVertexAttrib2fv(location, values);
+            else if (rows == 3)
+                glVertexAttrib3fv(location, values);
+            else
+                glVertexAttrib4fv(location, values);
+            values += rows;
+            ++location;
+        }
+    }
+}
+
+/*!
+    \overload
+
+    Sets the attribute called \a name in the current context to the
+    contents of \a values, which contains \a columns elements, each
+    consisting of \a rows elements.  The \a rows value should be
+    1, 2, 3, or 4.  This function is typically used to set matrix
+    values and column vectors.
+
+    \sa setUniformValue()
+*/
+void QGLShaderProgram::setAttributeValue
+    (const char *name, const GLfloat *values, int columns, int rows)
+{
+    setAttributeValue(attributeLocation(name), values, columns, rows);
+}
+
+/*!
+    Sets an array of vertex \a values on the attribute at \a location
+    in this shader program.  The \a tupleSize indicates the number of
+    components per vertex (1, 2, 3, or 4), and the \a stride indicates
+    the number of bytes between vertices.  A default \a stride value
+    of zero indicates that the vertices are densely packed in \a values.
+
+    The array will become active when enableAttributeArray() is called
+    on the \a location.  Otherwise the value specified with
+    setAttributeValue() for \a location will be used.
+
+    \sa setAttributeValue(), setUniformValue(), enableAttributeArray()
+    \sa disableAttributeArray()
+*/
+void QGLShaderProgram::setAttributeArray
+    (int location, const GLfloat *values, int tupleSize, int stride)
+{
+    Q_D(QGLShaderProgram);
+    Q_UNUSED(d);
+    if (location != -1) {
+        glVertexAttribPointer(location, tupleSize, GL_FLOAT, GL_FALSE,
+                              stride, values);
+    }
+}
+
+/*!
+    Sets an array of 2D vertex \a values on the attribute at \a location
+    in this shader program.  The \a stride indicates the number of bytes
+    between vertices.  A default \a stride value of zero indicates that
+    the vertices are densely packed in \a values.
+
+    The array will become active when enableAttributeArray() is called
+    on the \a location.  Otherwise the value specified with
+    setAttributeValue() for \a location will be used.
+
+    \sa setAttributeValue(), setUniformValue(), enableAttributeArray()
+    \sa disableAttributeArray()
+*/
+void QGLShaderProgram::setAttributeArray
+        (int location, const QVector2D *values, int stride)
+{
+    Q_D(QGLShaderProgram);
+    Q_UNUSED(d);
+    if (location != -1) {
+        glVertexAttribPointer(location, 2, GL_FLOAT, GL_FALSE,
+                              stride, values);
+    }
+}
+
+/*!
+    Sets an array of 3D vertex \a values on the attribute at \a location
+    in this shader program.  The \a stride indicates the number of bytes
+    between vertices.  A default \a stride value of zero indicates that
+    the vertices are densely packed in \a values.
+
+    The array will become active when enableAttributeArray() is called
+    on the \a location.  Otherwise the value specified with
+    setAttributeValue() for \a location will be used.
+
+    \sa setAttributeValue(), setUniformValue(), enableAttributeArray()
+    \sa disableAttributeArray()
+*/
+void QGLShaderProgram::setAttributeArray
+        (int location, const QVector3D *values, int stride)
+{
+    Q_D(QGLShaderProgram);
+    Q_UNUSED(d);
+    if (location != -1) {
+        glVertexAttribPointer(location, 3, GL_FLOAT, GL_FALSE,
+                              stride, values);
+    }
+}
+
+/*!
+    Sets an array of 4D vertex \a values on the attribute at \a location
+    in this shader program.  The \a stride indicates the number of bytes
+    between vertices.  A default \a stride value of zero indicates that
+    the vertices are densely packed in \a values.
+
+    The array will become active when enableAttributeArray() is called
+    on the \a location.  Otherwise the value specified with
+    setAttributeValue() for \a location will be used.
+
+    \sa setAttributeValue(), setUniformValue(), enableAttributeArray()
+    \sa disableAttributeArray()
+*/
+void QGLShaderProgram::setAttributeArray
+        (int location, const QVector4D *values, int stride)
+{
+    Q_D(QGLShaderProgram);
+    Q_UNUSED(d);
+    if (location != -1) {
+        glVertexAttribPointer(location, 4, GL_FLOAT, GL_FALSE,
+                              stride, values);
+    }
+}
+
+/*!
+    Sets an array of vertex \a values on the attribute at \a location
+    in this shader program.  The \a stride indicates the number of bytes
+    between vertices.  A default \a stride value of zero indicates that
+    the vertices are densely packed in \a values.
+
+    The \a type indicates the type of elements in the \a values array,
+    usually \c{GL_FLOAT}, \c{GL_UNSIGNED_BYTE}, etc.  The \a tupleSize
+    indicates the number of components per vertex: 1, 2, 3, or 4.
+
+    The array will become active when enableAttributeArray() is called
+    on the \a location.  Otherwise the value specified with
+    setAttributeValue() for \a location will be used.
+
+    The setAttributeBuffer() function can be used to set the attribute
+    array to an offset within a vertex buffer.
+
+    \sa setAttributeValue(), setUniformValue(), enableAttributeArray()
+    \sa disableAttributeArray(), setAttributeBuffer()
+    \since 4.7
+*/
+void QGLShaderProgram::setAttributeArray
+    (int location, GLenum type, const void *values, int tupleSize, int stride)
+{
+    Q_D(QGLShaderProgram);
+    Q_UNUSED(d);
+    if (location != -1) {
+        glVertexAttribPointer(location, tupleSize, type, GL_TRUE,
+                              stride, values);
+    }
+}
+
+/*!
+    \overload
+
+    Sets an array of vertex \a values on the attribute called \a name
+    in this shader program.  The \a tupleSize indicates the number of
+    components per vertex (1, 2, 3, or 4), and the \a stride indicates
+    the number of bytes between vertices.  A default \a stride value
+    of zero indicates that the vertices are densely packed in \a values.
+
+    The array will become active when enableAttributeArray() is called
+    on \a name.  Otherwise the value specified with setAttributeValue()
+    for \a name will be used.
+
+    \sa setAttributeValue(), setUniformValue(), enableAttributeArray()
+    \sa disableAttributeArray()
+*/
+void QGLShaderProgram::setAttributeArray
+    (const char *name, const GLfloat *values, int tupleSize, int stride)
+{
+    setAttributeArray(attributeLocation(name), values, tupleSize, stride);
+}
+
+/*!
+    \overload
+
+    Sets an array of 2D vertex \a values on the attribute called \a name
+    in this shader program.  The \a stride indicates the number of bytes
+    between vertices.  A default \a stride value of zero indicates that
+    the vertices are densely packed in \a values.
+
+    The array will become active when enableAttributeArray() is called
+    on \a name.  Otherwise the value specified with setAttributeValue()
+    for \a name will be used.
+
+    \sa setAttributeValue(), setUniformValue(), enableAttributeArray()
+    \sa disableAttributeArray()
+*/
+void QGLShaderProgram::setAttributeArray
+        (const char *name, const QVector2D *values, int stride)
+{
+    setAttributeArray(attributeLocation(name), values, stride);
+}
+
+/*!
+    \overload
+
+    Sets an array of 3D vertex \a values on the attribute called \a name
+    in this shader program.  The \a stride indicates the number of bytes
+    between vertices.  A default \a stride value of zero indicates that
+    the vertices are densely packed in \a values.
+
+    The array will become active when enableAttributeArray() is called
+    on \a name.  Otherwise the value specified with setAttributeValue()
+    for \a name will be used.
+
+    \sa setAttributeValue(), setUniformValue(), enableAttributeArray()
+    \sa disableAttributeArray()
+*/
+void QGLShaderProgram::setAttributeArray
+        (const char *name, const QVector3D *values, int stride)
+{
+    setAttributeArray(attributeLocation(name), values, stride);
+}
+
+/*!
+    \overload
+
+    Sets an array of 4D vertex \a values on the attribute called \a name
+    in this shader program.  The \a stride indicates the number of bytes
+    between vertices.  A default \a stride value of zero indicates that
+    the vertices are densely packed in \a values.
+
+    The array will become active when enableAttributeArray() is called
+    on \a name.  Otherwise the value specified with setAttributeValue()
+    for \a name will be used.
+
+    \sa setAttributeValue(), setUniformValue(), enableAttributeArray()
+    \sa disableAttributeArray()
+*/
+void QGLShaderProgram::setAttributeArray
+        (const char *name, const QVector4D *values, int stride)
+{
+    setAttributeArray(attributeLocation(name), values, stride);
+}
+
+/*!
+    \overload
+
+    Sets an array of vertex \a values on the attribute called \a name
+    in this shader program.  The \a stride indicates the number of bytes
+    between vertices.  A default \a stride value of zero indicates that
+    the vertices are densely packed in \a values.
+
+    The \a type indicates the type of elements in the \a values array,
+    usually \c{GL_FLOAT}, \c{GL_UNSIGNED_BYTE}, etc.  The \a tupleSize
+    indicates the number of components per vertex: 1, 2, 3, or 4.
+
+    The array will become active when enableAttributeArray() is called
+    on the \a name.  Otherwise the value specified with
+    setAttributeValue() for \a name will be used.
+
+    The setAttributeBuffer() function can be used to set the attribute
+    array to an offset within a vertex buffer.
+
+    \sa setAttributeValue(), setUniformValue(), enableAttributeArray()
+    \sa disableAttributeArray(), setAttributeBuffer()
+    \since 4.7
+*/
+void QGLShaderProgram::setAttributeArray
+    (const char *name, GLenum type, const void *values, int tupleSize, int stride)
+{
+    setAttributeArray(attributeLocation(name), type, values, tupleSize, stride);
+}
+
+/*!
+    Sets an array of vertex values on the attribute at \a location in
+    this shader program, starting at a specific \a offset in the
+    currently bound vertex buffer.  The \a stride indicates the number
+    of bytes between vertices.  A default \a stride value of zero
+    indicates that the vertices are densely packed in the value array.
+
+    The \a type indicates the type of elements in the vertex value
+    array, usually \c{GL_FLOAT}, \c{GL_UNSIGNED_BYTE}, etc.  The \a
+    tupleSize indicates the number of components per vertex: 1, 2, 3,
+    or 4.
+
+    The array will become active when enableAttributeArray() is called
+    on the \a location.  Otherwise the value specified with
+    setAttributeValue() for \a location will be used.
+
+    \sa setAttributeArray()
+    \since 4.7
+*/
+void QGLShaderProgram::setAttributeBuffer
+    (int location, GLenum type, int offset, int tupleSize, int stride)
+{
+    Q_D(QGLShaderProgram);
+    Q_UNUSED(d);
+    if (location != -1) {
+        glVertexAttribPointer(location, tupleSize, type, GL_TRUE, stride,
+                              reinterpret_cast<const void *>(offset));
+    }
+}
+
+/*!
+    \overload
+
+    Sets an array of vertex values on the attribute called \a name
+    in this shader program, starting at a specific \a offset in the
+    currently bound vertex buffer.  The \a stride indicates the number
+    of bytes between vertices.  A default \a stride value of zero
+    indicates that the vertices are densely packed in the value array.
+
+    The \a type indicates the type of elements in the vertex value
+    array, usually \c{GL_FLOAT}, \c{GL_UNSIGNED_BYTE}, etc.  The \a
+    tupleSize indicates the number of components per vertex: 1, 2, 3,
+    or 4.
+
+    The array will become active when enableAttributeArray() is called
+    on the \a name.  Otherwise the value specified with
+    setAttributeValue() for \a name will be used.
+
+    \sa setAttributeArray()
+    \since 4.7
+*/
+void QGLShaderProgram::setAttributeBuffer
+    (const char *name, GLenum type, int offset, int tupleSize, int stride)
+{
+    setAttributeBuffer(attributeLocation(name), type, offset, tupleSize, stride);
+}
+
+/*!
+    Enables the vertex array at \a location in this shader program
+    so that the value set by setAttributeArray() on \a location
+    will be used by the shader program.
+
+    \sa disableAttributeArray(), setAttributeArray(), setAttributeValue()
+    \sa setUniformValue()
+*/
+void QGLShaderProgram::enableAttributeArray(int location)
+{
+    Q_D(QGLShaderProgram);
+    Q_UNUSED(d);
+    if (location != -1)
+        glEnableVertexAttribArray(location);
+}
+
+/*!
+    \overload
+
+    Enables the vertex array called \a name in this shader program
+    so that the value set by setAttributeArray() on \a name
+    will be used by the shader program.
+
+    \sa disableAttributeArray(), setAttributeArray(), setAttributeValue()
+    \sa setUniformValue()
+*/
+void QGLShaderProgram::enableAttributeArray(const char *name)
+{
+    enableAttributeArray(attributeLocation(name));
+}
+
+/*!
+    Disables the vertex array at \a location in this shader program
+    that was enabled by a previous call to enableAttributeArray().
+
+    \sa enableAttributeArray(), setAttributeArray(), setAttributeValue()
+    \sa setUniformValue()
+*/
+void QGLShaderProgram::disableAttributeArray(int location)
+{
+    Q_D(QGLShaderProgram);
+    Q_UNUSED(d);
+    if (location != -1)
+        glDisableVertexAttribArray(location);
+}
+
+/*!
+    \overload
+
+    Disables the vertex array called \a name in this shader program
+    that was enabled by a previous call to enableAttributeArray().
+
+    \sa enableAttributeArray(), setAttributeArray(), setAttributeValue()
+    \sa setUniformValue()
+*/
+void QGLShaderProgram::disableAttributeArray(const char *name)
+{
+    disableAttributeArray(attributeLocation(name));
+}
+
+/*!
+    Returns the location of the uniform variable \a name within this shader
+    program's parameter list.  Returns -1 if \a name is not a valid
+    uniform variable for this shader program.
+
+    \sa attributeLocation()
+*/
+int QGLShaderProgram::uniformLocation(const char *name) const
+{
+    Q_D(const QGLShaderProgram);
+    Q_UNUSED(d);
+    if (d->linked) {
+        return glGetUniformLocation(d->programGuard.id(), name);
+    } else {
+        qWarning() << "QGLShaderProgram::uniformLocation(" << name
+                   << "): shader program is not linked";
+        return -1;
+    }
+}
+
+/*!
+    \overload
+
+    Returns the location of the uniform variable \a name within this shader
+    program's parameter list.  Returns -1 if \a name is not a valid
+    uniform variable for this shader program.
+
+    \sa attributeLocation()
+*/
+int QGLShaderProgram::uniformLocation(const QByteArray& name) const
+{
+    return uniformLocation(name.constData());
+}
+
+/*!
+    \overload
+
+    Returns the location of the uniform variable \a name within this shader
+    program's parameter list.  Returns -1 if \a name is not a valid
+    uniform variable for this shader program.
+
+    \sa attributeLocation()
+*/
+int QGLShaderProgram::uniformLocation(const QString& name) const
+{
+    return uniformLocation(name.toLatin1().constData());
+}
+
+/*!
+    Sets the uniform variable at \a location in the current context to \a value.
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValue(int location, GLfloat value)
+{
+    Q_D(QGLShaderProgram);
+    Q_UNUSED(d);
+    if (location != -1)
+        glUniform1fv(location, 1, &value);
+}
+
+/*!
+    \overload
+
+    Sets the uniform variable called \a name in the current context
+    to \a value.
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValue(const char *name, GLfloat value)
+{
+    setUniformValue(uniformLocation(name), value);
+}
+
+/*!
+    Sets the uniform variable at \a location in the current context to \a value.
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValue(int location, GLint value)
+{
+    Q_D(QGLShaderProgram);
+    Q_UNUSED(d);
+    if (location != -1)
+        glUniform1i(location, value);
+}
+
+/*!
+    \overload
+
+    Sets the uniform variable called \a name in the current context
+    to \a value.
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValue(const char *name, GLint value)
+{
+    setUniformValue(uniformLocation(name), value);
+}
+
+/*!
+    Sets the uniform variable at \a location in the current context to \a value.
+    This function should be used when setting sampler values.
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValue(int location, GLuint value)
+{
+    Q_D(QGLShaderProgram);
+    Q_UNUSED(d);
+    if (location != -1)
+        glUniform1i(location, value);
+}
+
+/*!
+    \overload
+
+    Sets the uniform variable called \a name in the current context
+    to \a value.  This function should be used when setting sampler values.
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValue(const char *name, GLuint value)
+{
+    setUniformValue(uniformLocation(name), value);
+}
+
+/*!
+    Sets the uniform variable at \a location in the current context to
+    the 2D vector (\a x, \a y).
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValue(int location, GLfloat x, GLfloat y)
+{
+    Q_D(QGLShaderProgram);
+    Q_UNUSED(d);
+    if (location != -1) {
+        GLfloat values[2] = {x, y};
+        glUniform2fv(location, 1, values);
+    }
+}
+
+/*!
+    \overload
+
+    Sets the uniform variable called \a name in the current context to
+    the 2D vector (\a x, \a y).
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValue(const char *name, GLfloat x, GLfloat y)
+{
+    setUniformValue(uniformLocation(name), x, y);
+}
+
+/*!
+    Sets the uniform variable at \a location in the current context to
+    the 3D vector (\a x, \a y, \a z).
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValue
+        (int location, GLfloat x, GLfloat y, GLfloat z)
+{
+    Q_D(QGLShaderProgram);
+    Q_UNUSED(d);
+    if (location != -1) {
+        GLfloat values[3] = {x, y, z};
+        glUniform3fv(location, 1, values);
+    }
+}
+
+/*!
+    \overload
+
+    Sets the uniform variable called \a name in the current context to
+    the 3D vector (\a x, \a y, \a z).
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValue
+        (const char *name, GLfloat x, GLfloat y, GLfloat z)
+{
+    setUniformValue(uniformLocation(name), x, y, z);
+}
+
+/*!
+    Sets the uniform variable at \a location in the current context to
+    the 4D vector (\a x, \a y, \a z, \a w).
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValue
+        (int location, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+{
+    Q_D(QGLShaderProgram);
+    Q_UNUSED(d);
+    if (location != -1) {
+        GLfloat values[4] = {x, y, z, w};
+        glUniform4fv(location, 1, values);
+    }
+}
+
+/*!
+    \overload
+
+    Sets the uniform variable called \a name in the current context to
+    the 4D vector (\a x, \a y, \a z, \a w).
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValue
+        (const char *name, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+{
+    setUniformValue(uniformLocation(name), x, y, z, w);
+}
+
+/*!
+    Sets the uniform variable at \a location in the current context to \a value.
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValue(int location, const QVector2D& value)
+{
+    Q_D(QGLShaderProgram);
+    Q_UNUSED(d);
+    if (location != -1)
+        glUniform2fv(location, 1, reinterpret_cast<const GLfloat *>(&value));
+}
+
+/*!
+    \overload
+
+    Sets the uniform variable called \a name in the current context
+    to \a value.
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValue(const char *name, const QVector2D& value)
+{
+    setUniformValue(uniformLocation(name), value);
+}
+
+/*!
+    Sets the uniform variable at \a location in the current context to \a value.
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValue(int location, const QVector3D& value)
+{
+    Q_D(QGLShaderProgram);
+    Q_UNUSED(d);
+    if (location != -1)
+        glUniform3fv(location, 1, reinterpret_cast<const GLfloat *>(&value));
+}
+
+/*!
+    \overload
+
+    Sets the uniform variable called \a name in the current context
+    to \a value.
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValue(const char *name, const QVector3D& value)
+{
+    setUniformValue(uniformLocation(name), value);
+}
+
+/*!
+    Sets the uniform variable at \a location in the current context to \a value.
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValue(int location, const QVector4D& value)
+{
+    Q_D(QGLShaderProgram);
+    Q_UNUSED(d);
+    if (location != -1)
+        glUniform4fv(location, 1, reinterpret_cast<const GLfloat *>(&value));
+}
+
+/*!
+    \overload
+
+    Sets the uniform variable called \a name in the current context
+    to \a value.
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValue(const char *name, const QVector4D& value)
+{
+    setUniformValue(uniformLocation(name), value);
+}
+
+/*!
+    Sets the uniform variable at \a location in the current context to
+    the red, green, blue, and alpha components of \a color.
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValue(int location, const QColor& color)
+{
+    Q_D(QGLShaderProgram);
+    Q_UNUSED(d);
+    if (location != -1) {
+        GLfloat values[4] = {GLfloat(color.redF()), GLfloat(color.greenF()),
+                             GLfloat(color.blueF()), GLfloat(color.alphaF())};
+        glUniform4fv(location, 1, values);
+    }
+}
+
+/*!
+    \overload
+
+    Sets the uniform variable called \a name in the current context to
+    the red, green, blue, and alpha components of \a color.
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValue(const char *name, const QColor& color)
+{
+    setUniformValue(uniformLocation(name), color);
+}
+
+/*!
+    Sets the uniform variable at \a location in the current context to
+    the x and y coordinates of \a point.
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValue(int location, const QPoint& point)
+{
+    Q_D(QGLShaderProgram);
+    Q_UNUSED(d);
+    if (location != -1) {
+        GLfloat values[4] = {GLfloat(point.x()), GLfloat(point.y())};
+        glUniform2fv(location, 1, values);
+    }
+}
+
+/*!
+    \overload
+
+    Sets the uniform variable associated with \a name in the current
+    context to the x and y coordinates of \a point.
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValue(const char *name, const QPoint& point)
+{
+    setUniformValue(uniformLocation(name), point);
+}
+
+/*!
+    Sets the uniform variable at \a location in the current context to
+    the x and y coordinates of \a point.
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValue(int location, const QPointF& point)
+{
+    Q_D(QGLShaderProgram);
+    Q_UNUSED(d);
+    if (location != -1) {
+        GLfloat values[4] = {GLfloat(point.x()), GLfloat(point.y())};
+        glUniform2fv(location, 1, values);
+    }
+}
+
+/*!
+    \overload
+
+    Sets the uniform variable associated with \a name in the current
+    context to the x and y coordinates of \a point.
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValue(const char *name, const QPointF& point)
+{
+    setUniformValue(uniformLocation(name), point);
+}
+
+/*!
+    Sets the uniform variable at \a location in the current context to
+    the width and height of the given \a size.
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValue(int location, const QSize& size)
+{
+    Q_D(QGLShaderProgram);
+    Q_UNUSED(d);
+    if (location != -1) {
+        GLfloat values[4] = {GLfloat(size.width()), GLfloat(size.height())};
+        glUniform2fv(location, 1, values);
+    }
+}
+
+/*!
+    \overload
+
+    Sets the uniform variable associated with \a name in the current
+    context to the width and height of the given \a size.
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValue(const char *name, const QSize& size)
+{
+    setUniformValue(uniformLocation(name), size);
+}
+
+/*!
+    Sets the uniform variable at \a location in the current context to
+    the width and height of the given \a size.
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValue(int location, const QSizeF& size)
+{
+    Q_D(QGLShaderProgram);
+    Q_UNUSED(d);
+    if (location != -1) {
+        GLfloat values[4] = {GLfloat(size.width()), GLfloat(size.height())};
+        glUniform2fv(location, 1, values);
+    }
+}
+
+/*!
+    \overload
+
+    Sets the uniform variable associated with \a name in the current
+    context to the width and height of the given \a size.
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValue(const char *name, const QSizeF& size)
+{
+    setUniformValue(uniformLocation(name), size);
+}
+
+// We have to repack matrices from qreal to GLfloat.
+#define setUniformMatrix(func,location,value,cols,rows) \
+    if (location == -1) \
+        return; \
+    if (sizeof(qreal) == sizeof(GLfloat)) { \
+        func(location, 1, GL_FALSE, \
+             reinterpret_cast<const GLfloat *>(value.constData())); \
+    } else { \
+        GLfloat mat[cols * rows]; \
+        const qreal *data = value.constData(); \
+        for (int i = 0; i < cols * rows; ++i) \
+            mat[i] = data[i]; \
+        func(location, 1, GL_FALSE, mat); \
+    }
+#if !defined(QT_OPENGL_ES_2)
+#define setUniformGenericMatrix(func,colfunc,location,value,cols,rows) \
+    if (location == -1) \
+        return; \
+    if (sizeof(qreal) == sizeof(GLfloat)) { \
+        const GLfloat *data = reinterpret_cast<const GLfloat *> \
+            (value.constData());  \
+        if (func) \
+            func(location, 1, GL_FALSE, data); \
+        else \
+            colfunc(location, cols, data); \
+    } else { \
+        GLfloat mat[cols * rows]; \
+        const qreal *data = value.constData(); \
+        for (int i = 0; i < cols * rows; ++i) \
+            mat[i] = data[i]; \
+        if (func) \
+            func(location, 1, GL_FALSE, mat); \
+        else \
+            colfunc(location, cols, mat); \
+    }
+#else
+#define setUniformGenericMatrix(func,colfunc,location,value,cols,rows) \
+    if (location == -1) \
+        return; \
+    if (sizeof(qreal) == sizeof(GLfloat)) { \
+        const GLfloat *data = reinterpret_cast<const GLfloat *> \
+            (value.constData());  \
+        colfunc(location, cols, data); \
+    } else { \
+        GLfloat mat[cols * rows]; \
+        const qreal *data = value.constData(); \
+        for (int i = 0; i < cols * rows; ++i) \
+            mat[i] = data[i]; \
+        colfunc(location, cols, mat); \
+    }
+#endif
+
+/*!
+    Sets the uniform variable at \a location in the current context
+    to a 2x2 matrix \a value.
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValue(int location, const QMatrix2x2& value)
+{
+    Q_D(QGLShaderProgram);
+    Q_UNUSED(d);
+    setUniformMatrix(glUniformMatrix2fv, location, value, 2, 2);
+}
+
+/*!
+    \overload
+
+    Sets the uniform variable called \a name in the current context
+    to a 2x2 matrix \a value.
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValue(const char *name, const QMatrix2x2& value)
+{
+    setUniformValue(uniformLocation(name), value);
+}
+
+/*!
+    Sets the uniform variable at \a location in the current context
+    to a 2x3 matrix \a value.
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValue(int location, const QMatrix2x3& value)
+{
+    Q_D(QGLShaderProgram);
+    Q_UNUSED(d);
+    setUniformGenericMatrix
+        (glUniformMatrix2x3fv, glUniform3fv, location, value, 2, 3);
+}
+
+/*!
+    \overload
+
+    Sets the uniform variable called \a name in the current context
+    to a 2x3 matrix \a value.
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValue(const char *name, const QMatrix2x3& value)
+{
+    setUniformValue(uniformLocation(name), value);
+}
+
+/*!
+    Sets the uniform variable at \a location in the current context
+    to a 2x4 matrix \a value.
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValue(int location, const QMatrix2x4& value)
+{
+    Q_D(QGLShaderProgram);
+    Q_UNUSED(d);
+    setUniformGenericMatrix
+        (glUniformMatrix2x4fv, glUniform4fv, location, value, 2, 4);
+}
+
+/*!
+    \overload
+
+    Sets the uniform variable called \a name in the current context
+    to a 2x4 matrix \a value.
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValue(const char *name, const QMatrix2x4& value)
+{
+    setUniformValue(uniformLocation(name), value);
+}
+
+/*!
+    Sets the uniform variable at \a location in the current context
+    to a 3x2 matrix \a value.
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValue(int location, const QMatrix3x2& value)
+{
+    Q_D(QGLShaderProgram);
+    Q_UNUSED(d);
+    setUniformGenericMatrix
+        (glUniformMatrix3x2fv, glUniform2fv, location, value, 3, 2);
+}
+
+/*!
+    \overload
+
+    Sets the uniform variable called \a name in the current context
+    to a 3x2 matrix \a value.
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValue(const char *name, const QMatrix3x2& value)
+{
+    setUniformValue(uniformLocation(name), value);
+}
+
+/*!
+    Sets the uniform variable at \a location in the current context
+    to a 3x3 matrix \a value.
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValue(int location, const QMatrix3x3& value)
+{
+    Q_D(QGLShaderProgram);
+    Q_UNUSED(d);
+    setUniformMatrix(glUniformMatrix3fv, location, value, 3, 3);
+}
+
+/*!
+    \overload
+
+    Sets the uniform variable called \a name in the current context
+    to a 3x3 matrix \a value.
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValue(const char *name, const QMatrix3x3& value)
+{
+    setUniformValue(uniformLocation(name), value);
+}
+
+/*!
+    Sets the uniform variable at \a location in the current context
+    to a 3x4 matrix \a value.
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValue(int location, const QMatrix3x4& value)
+{
+    Q_D(QGLShaderProgram);
+    Q_UNUSED(d);
+    setUniformGenericMatrix
+        (glUniformMatrix3x4fv, glUniform4fv, location, value, 3, 4);
+}
+
+/*!
+    \overload
+
+    Sets the uniform variable called \a name in the current context
+    to a 3x4 matrix \a value.
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValue(const char *name, const QMatrix3x4& value)
+{
+    setUniformValue(uniformLocation(name), value);
+}
+
+/*!
+    Sets the uniform variable at \a location in the current context
+    to a 4x2 matrix \a value.
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValue(int location, const QMatrix4x2& value)
+{
+    Q_D(QGLShaderProgram);
+    Q_UNUSED(d);
+    setUniformGenericMatrix
+        (glUniformMatrix4x2fv, glUniform2fv, location, value, 4, 2);
+}
+
+/*!
+    \overload
+
+    Sets the uniform variable called \a name in the current context
+    to a 4x2 matrix \a value.
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValue(const char *name, const QMatrix4x2& value)
+{
+    setUniformValue(uniformLocation(name), value);
+}
+
+/*!
+    Sets the uniform variable at \a location in the current context
+    to a 4x3 matrix \a value.
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValue(int location, const QMatrix4x3& value)
+{
+    Q_D(QGLShaderProgram);
+    Q_UNUSED(d);
+    setUniformGenericMatrix
+        (glUniformMatrix4x3fv, glUniform3fv, location, value, 4, 3);
+}
+
+/*!
+    \overload
+
+    Sets the uniform variable called \a name in the current context
+    to a 4x3 matrix \a value.
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValue(const char *name, const QMatrix4x3& value)
+{
+    setUniformValue(uniformLocation(name), value);
+}
+
+/*!
+    Sets the uniform variable at \a location in the current context
+    to a 4x4 matrix \a value.
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValue(int location, const QMatrix4x4& value)
+{
+    Q_D(QGLShaderProgram);
+    Q_UNUSED(d);
+    setUniformMatrix(glUniformMatrix4fv, location, value, 4, 4);
+}
+
+/*!
+    \overload
+
+    Sets the uniform variable called \a name in the current context
+    to a 4x4 matrix \a value.
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValue(const char *name, const QMatrix4x4& value)
+{
+    setUniformValue(uniformLocation(name), value);
+}
+
+/*!
+    \overload
+
+    Sets the uniform variable at \a location in the current context
+    to a 2x2 matrix \a value.  The matrix elements must be specified
+    in column-major order.
+
+    \sa setAttributeValue()
+    \since 4.7
+*/
+void QGLShaderProgram::setUniformValue(int location, const GLfloat value[2][2])
+{
+    Q_D(QGLShaderProgram);
+    Q_UNUSED(d);
+    if (location != -1)
+        glUniformMatrix2fv(location, 1, GL_FALSE, value[0]);
+}
+
+/*!
+    \overload
+
+    Sets the uniform variable at \a location in the current context
+    to a 3x3 matrix \a value.  The matrix elements must be specified
+    in column-major order.
+
+    \sa setAttributeValue()
+    \since 4.7
+*/
+void QGLShaderProgram::setUniformValue(int location, const GLfloat value[3][3])
+{
+    Q_D(QGLShaderProgram);
+    Q_UNUSED(d);
+    if (location != -1)
+        glUniformMatrix3fv(location, 1, GL_FALSE, value[0]);
+}
+
+/*!
+    \overload
+
+    Sets the uniform variable at \a location in the current context
+    to a 4x4 matrix \a value.  The matrix elements must be specified
+    in column-major order.
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValue(int location, const GLfloat value[4][4])
+{
+    Q_D(QGLShaderProgram);
+    Q_UNUSED(d);
+    if (location != -1)
+        glUniformMatrix4fv(location, 1, GL_FALSE, value[0]);
+}
+
+
+/*!
+    \overload
+
+    Sets the uniform variable called \a name in the current context
+    to a 2x2 matrix \a value.  The matrix elements must be specified
+    in column-major order.
+
+    \sa setAttributeValue()
+    \since 4.7
+*/
+void QGLShaderProgram::setUniformValue(const char *name, const GLfloat value[2][2])
+{
+    setUniformValue(uniformLocation(name), value);
+}
+
+/*!
+    \overload
+
+    Sets the uniform variable called \a name in the current context
+    to a 3x3 matrix \a value.  The matrix elements must be specified
+    in column-major order.
+
+    \sa setAttributeValue()
+    \since 4.7
+*/
+void QGLShaderProgram::setUniformValue(const char *name, const GLfloat value[3][3])
+{
+    setUniformValue(uniformLocation(name), value);
+}
+
+/*!
+    \overload
+
+    Sets the uniform variable called \a name in the current context
+    to a 4x4 matrix \a value.  The matrix elements must be specified
+    in column-major order.
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValue(const char *name, const GLfloat value[4][4])
+{
+    setUniformValue(uniformLocation(name), value);
+}
+
+/*!
+    Sets the uniform variable at \a location in the current context to a
+    3x3 transformation matrix \a value that is specified as a QTransform value.
+
+    To set a QTransform value as a 4x4 matrix in a shader, use
+    \c{setUniformValue(location, QMatrix4x4(value))}.
+*/
+void QGLShaderProgram::setUniformValue(int location, const QTransform& value)
+{
+    Q_D(QGLShaderProgram);
+    Q_UNUSED(d);
+    if (location != -1) {
+        GLfloat mat[3][3] = {
+            {GLfloat(value.m11()), GLfloat(value.m12()), GLfloat(value.m13())},
+            {GLfloat(value.m21()), GLfloat(value.m22()), GLfloat(value.m23())},
+            {GLfloat(value.m31()), GLfloat(value.m32()), GLfloat(value.m33())}
+        };
+        glUniformMatrix3fv(location, 1, GL_FALSE, mat[0]);
+    }
+}
+
+/*!
+    \overload
+
+    Sets the uniform variable called \a name in the current context to a
+    3x3 transformation matrix \a value that is specified as a QTransform value.
+
+    To set a QTransform value as a 4x4 matrix in a shader, use
+    \c{setUniformValue(name, QMatrix4x4(value))}.
+*/
+void QGLShaderProgram::setUniformValue
+        (const char *name, const QTransform& value)
+{
+    setUniformValue(uniformLocation(name), value);
+}
+
+/*!
+    Sets the uniform variable array at \a location in the current
+    context to the \a count elements of \a values.
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValueArray(int location, const GLint *values, int count)
+{
+    Q_D(QGLShaderProgram);
+    Q_UNUSED(d);
+    if (location != -1)
+        glUniform1iv(location, count, values);
+}
+
+/*!
+    \overload
+
+    Sets the uniform variable array called \a name in the current
+    context to the \a count elements of \a values.
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValueArray
+        (const char *name, const GLint *values, int count)
+{
+    setUniformValueArray(uniformLocation(name), values, count);
+}
+
+/*!
+    Sets the uniform variable array at \a location in the current
+    context to the \a count elements of \a values.  This overload
+    should be used when setting an array of sampler values.
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValueArray(int location, const GLuint *values, int count)
+{
+    Q_D(QGLShaderProgram);
+    Q_UNUSED(d);
+    if (location != -1)
+        glUniform1iv(location, count, reinterpret_cast<const GLint *>(values));
+}
+
+/*!
+    \overload
+
+    Sets the uniform variable array called \a name in the current
+    context to the \a count elements of \a values.  This overload
+    should be used when setting an array of sampler values.
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValueArray
+        (const char *name, const GLuint *values, int count)
+{
+    setUniformValueArray(uniformLocation(name), values, count);
+}
+
+/*!
+    Sets the uniform variable array at \a location in the current
+    context to the \a count elements of \a values.  Each element
+    has \a tupleSize components.  The \a tupleSize must be 1, 2, 3, or 4.
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValueArray(int location, const GLfloat *values, int count, int tupleSize)
+{
+    Q_D(QGLShaderProgram);
+    Q_UNUSED(d);
+    if (location != -1) {
+        if (tupleSize == 1)
+            glUniform1fv(location, count, values);
+        else if (tupleSize == 2)
+            glUniform2fv(location, count, values);
+        else if (tupleSize == 3)
+            glUniform3fv(location, count, values);
+        else if (tupleSize == 4)
+            glUniform4fv(location, count, values);
+        else
+            qWarning() << "QGLShaderProgram::setUniformValue: size" << tupleSize << "not supported";
+    }
+}
+
+/*!
+    \overload
+
+    Sets the uniform variable array called \a name in the current
+    context to the \a count elements of \a values.  Each element
+    has \a tupleSize components.  The \a tupleSize must be 1, 2, 3, or 4.
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValueArray
+        (const char *name, const GLfloat *values, int count, int tupleSize)
+{
+    setUniformValueArray(uniformLocation(name), values, count, tupleSize);
+}
+
+/*!
+    Sets the uniform variable array at \a location in the current
+    context to the \a count 2D vector elements of \a values.
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValueArray(int location, const QVector2D *values, int count)
+{
+    Q_D(QGLShaderProgram);
+    Q_UNUSED(d);
+    if (location != -1)
+        glUniform2fv(location, count, reinterpret_cast<const GLfloat *>(values));
+}
+
+/*!
+    \overload
+
+    Sets the uniform variable array called \a name in the current
+    context to the \a count 2D vector elements of \a values.
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValueArray(const char *name, const QVector2D *values, int count)
+{
+    setUniformValueArray(uniformLocation(name), values, count);
+}
+
+/*!
+    Sets the uniform variable array at \a location in the current
+    context to the \a count 3D vector elements of \a values.
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValueArray(int location, const QVector3D *values, int count)
+{
+    Q_D(QGLShaderProgram);
+    Q_UNUSED(d);
+    if (location != -1)
+        glUniform3fv(location, count, reinterpret_cast<const GLfloat *>(values));
+}
+
+/*!
+    \overload
+
+    Sets the uniform variable array called \a name in the current
+    context to the \a count 3D vector elements of \a values.
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValueArray(const char *name, const QVector3D *values, int count)
+{
+    setUniformValueArray(uniformLocation(name), values, count);
+}
+
+/*!
+    Sets the uniform variable array at \a location in the current
+    context to the \a count 4D vector elements of \a values.
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValueArray(int location, const QVector4D *values, int count)
+{
+    Q_D(QGLShaderProgram);
+    Q_UNUSED(d);
+    if (location != -1)
+        glUniform4fv(location, count, reinterpret_cast<const GLfloat *>(values));
+}
+
+/*!
+    \overload
+
+    Sets the uniform variable array called \a name in the current
+    context to the \a count 4D vector elements of \a values.
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValueArray(const char *name, const QVector4D *values, int count)
+{
+    setUniformValueArray(uniformLocation(name), values, count);
+}
+
+// We have to repack matrix arrays from qreal to GLfloat.
+#define setUniformMatrixArray(func,location,values,count,type,cols,rows) \
+    if (location == -1 || count <= 0) \
+        return; \
+    if (sizeof(type) == sizeof(GLfloat) * cols * rows) { \
+        func(location, count, GL_FALSE, \
+             reinterpret_cast<const GLfloat *>(values[0].constData())); \
+    } else { \
+        QVarLengthArray<GLfloat> temp(cols * rows * count); \
+        for (int index = 0; index < count; ++index) { \
+            for (int index2 = 0; index2 < (cols * rows); ++index2) { \
+                temp.data()[cols * rows * index + index2] = \
+                    values[index].constData()[index2]; \
+            } \
+        } \
+        func(location, count, GL_FALSE, temp.constData()); \
+    }
+#if !defined(QT_OPENGL_ES_2)
+#define setUniformGenericMatrixArray(func,colfunc,location,values,count,type,cols,rows) \
+    if (location == -1 || count <= 0) \
+        return; \
+    if (sizeof(type) == sizeof(GLfloat) * cols * rows) { \
+        const GLfloat *data = reinterpret_cast<const GLfloat *> \
+            (values[0].constData());  \
+        if (func) \
+            func(location, count, GL_FALSE, data); \
+        else \
+            colfunc(location, count * cols, data); \
+    } else { \
+        QVarLengthArray<GLfloat> temp(cols * rows * count); \
+        for (int index = 0; index < count; ++index) { \
+            for (int index2 = 0; index2 < (cols * rows); ++index2) { \
+                temp.data()[cols * rows * index + index2] = \
+                    values[index].constData()[index2]; \
+            } \
+        } \
+        if (func) \
+            func(location, count, GL_FALSE, temp.constData()); \
+        else \
+            colfunc(location, count * cols, temp.constData()); \
+    }
+#else
+#define setUniformGenericMatrixArray(func,colfunc,location,values,count,type,cols,rows) \
+    if (location == -1 || count <= 0) \
+        return; \
+    if (sizeof(type) == sizeof(GLfloat) * cols * rows) { \
+        const GLfloat *data = reinterpret_cast<const GLfloat *> \
+            (values[0].constData());  \
+        colfunc(location, count * cols, data); \
+    } else { \
+        QVarLengthArray<GLfloat> temp(cols * rows * count); \
+        for (int index = 0; index < count; ++index) { \
+            for (int index2 = 0; index2 < (cols * rows); ++index2) { \
+                temp.data()[cols * rows * index + index2] = \
+                    values[index].constData()[index2]; \
+            } \
+        } \
+        colfunc(location, count * cols, temp.constData()); \
+    }
+#endif
+
+/*!
+    Sets the uniform variable array at \a location in the current
+    context to the \a count 2x2 matrix elements of \a values.
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValueArray(int location, const QMatrix2x2 *values, int count)
+{
+    Q_D(QGLShaderProgram);
+    Q_UNUSED(d);
+    setUniformMatrixArray
+        (glUniformMatrix2fv, location, values, count, QMatrix2x2, 2, 2);
+}
+
+/*!
+    \overload
+
+    Sets the uniform variable array called \a name in the current
+    context to the \a count 2x2 matrix elements of \a values.
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValueArray(const char *name, const QMatrix2x2 *values, int count)
+{
+    setUniformValueArray(uniformLocation(name), values, count);
+}
+
+/*!
+    Sets the uniform variable array at \a location in the current
+    context to the \a count 2x3 matrix elements of \a values.
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValueArray(int location, const QMatrix2x3 *values, int count)
+{
+    Q_D(QGLShaderProgram);
+    Q_UNUSED(d);
+    setUniformGenericMatrixArray
+        (glUniformMatrix2x3fv, glUniform3fv, location, values, count,
+         QMatrix2x3, 2, 3);
+}
+
+/*!
+    \overload
+
+    Sets the uniform variable array called \a name in the current
+    context to the \a count 2x3 matrix elements of \a values.
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValueArray(const char *name, const QMatrix2x3 *values, int count)
+{
+    setUniformValueArray(uniformLocation(name), values, count);
+}
+
+/*!
+    Sets the uniform variable array at \a location in the current
+    context to the \a count 2x4 matrix elements of \a values.
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValueArray(int location, const QMatrix2x4 *values, int count)
+{
+    Q_D(QGLShaderProgram);
+    Q_UNUSED(d);
+    setUniformGenericMatrixArray
+        (glUniformMatrix2x4fv, glUniform4fv, location, values, count,
+         QMatrix2x4, 2, 4);
+}
+
+/*!
+    \overload
+
+    Sets the uniform variable array called \a name in the current
+    context to the \a count 2x4 matrix elements of \a values.
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValueArray(const char *name, const QMatrix2x4 *values, int count)
+{
+    setUniformValueArray(uniformLocation(name), values, count);
+}
+
+/*!
+    Sets the uniform variable array at \a location in the current
+    context to the \a count 3x2 matrix elements of \a values.
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValueArray(int location, const QMatrix3x2 *values, int count)
+{
+    Q_D(QGLShaderProgram);
+    Q_UNUSED(d);
+    setUniformGenericMatrixArray
+        (glUniformMatrix3x2fv, glUniform2fv, location, values, count,
+         QMatrix3x2, 3, 2);
+}
+
+/*!
+    \overload
+
+    Sets the uniform variable array called \a name in the current
+    context to the \a count 3x2 matrix elements of \a values.
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValueArray(const char *name, const QMatrix3x2 *values, int count)
+{
+    setUniformValueArray(uniformLocation(name), values, count);
+}
+
+/*!
+    Sets the uniform variable array at \a location in the current
+    context to the \a count 3x3 matrix elements of \a values.
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValueArray(int location, const QMatrix3x3 *values, int count)
+{
+    Q_D(QGLShaderProgram);
+    Q_UNUSED(d);
+    setUniformMatrixArray
+        (glUniformMatrix3fv, location, values, count, QMatrix3x3, 3, 3);
+}
+
+/*!
+    \overload
+
+    Sets the uniform variable array called \a name in the current
+    context to the \a count 3x3 matrix elements of \a values.
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValueArray(const char *name, const QMatrix3x3 *values, int count)
+{
+    setUniformValueArray(uniformLocation(name), values, count);
+}
+
+/*!
+    Sets the uniform variable array at \a location in the current
+    context to the \a count 3x4 matrix elements of \a values.
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValueArray(int location, const QMatrix3x4 *values, int count)
+{
+    Q_D(QGLShaderProgram);
+    Q_UNUSED(d);
+    setUniformGenericMatrixArray
+        (glUniformMatrix3x4fv, glUniform4fv, location, values, count,
+         QMatrix3x4, 3, 4);
+}
+
+/*!
+    \overload
+
+    Sets the uniform variable array called \a name in the current
+    context to the \a count 3x4 matrix elements of \a values.
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValueArray(const char *name, const QMatrix3x4 *values, int count)
+{
+    setUniformValueArray(uniformLocation(name), values, count);
+}
+
+/*!
+    Sets the uniform variable array at \a location in the current
+    context to the \a count 4x2 matrix elements of \a values.
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValueArray(int location, const QMatrix4x2 *values, int count)
+{
+    Q_D(QGLShaderProgram);
+    Q_UNUSED(d);
+    setUniformGenericMatrixArray
+        (glUniformMatrix4x2fv, glUniform2fv, location, values, count,
+         QMatrix4x2, 4, 2);
+}
+
+/*!
+    \overload
+
+    Sets the uniform variable array called \a name in the current
+    context to the \a count 4x2 matrix elements of \a values.
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValueArray(const char *name, const QMatrix4x2 *values, int count)
+{
+    setUniformValueArray(uniformLocation(name), values, count);
+}
+
+/*!
+    Sets the uniform variable array at \a location in the current
+    context to the \a count 4x3 matrix elements of \a values.
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValueArray(int location, const QMatrix4x3 *values, int count)
+{
+    Q_D(QGLShaderProgram);
+    Q_UNUSED(d);
+    setUniformGenericMatrixArray
+        (glUniformMatrix4x3fv, glUniform3fv, location, values, count,
+         QMatrix4x3, 4, 3);
+}
+
+/*!
+    \overload
+
+    Sets the uniform variable array called \a name in the current
+    context to the \a count 4x3 matrix elements of \a values.
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValueArray(const char *name, const QMatrix4x3 *values, int count)
+{
+    setUniformValueArray(uniformLocation(name), values, count);
+}
+
+/*!
+    Sets the uniform variable array at \a location in the current
+    context to the \a count 4x4 matrix elements of \a values.
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValueArray(int location, const QMatrix4x4 *values, int count)
+{
+    Q_D(QGLShaderProgram);
+    Q_UNUSED(d);
+    setUniformMatrixArray
+        (glUniformMatrix4fv, location, values, count, QMatrix4x4, 4, 4);
+}
+
+/*!
+    \overload
+
+    Sets the uniform variable array called \a name in the current
+    context to the \a count 4x4 matrix elements of \a values.
+
+    \sa setAttributeValue()
+*/
+void QGLShaderProgram::setUniformValueArray(const char *name, const QMatrix4x4 *values, int count)
+{
+    setUniformValueArray(uniformLocation(name), values, count);
+}
+
+#undef ctx
+
+/*!
+    Returns the hardware limit for how many vertices a geometry shader
+    can output.
+
+    \since 4.7
+
+    \sa setGeometryOutputVertexCount()
+*/
+int QGLShaderProgram::maxGeometryOutputVertices() const
+{
+    GLint n;
+    glGetIntegerv(GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT, &n);
+    return n;
+}
+
+/*!
+    Sets the maximum number of vertices the current geometry shader
+    program will produce, if active, to \a count.
+
+    \since 4.7
+
+    This parameter takes effect the next time the program is linked.
+*/
+void QGLShaderProgram::setGeometryOutputVertexCount(int count)
+{
+#ifndef QT_NO_DEBUG
+    int max = maxGeometryOutputVertices();
+    if (count > max) {
+        qWarning("QGLShaderProgram::setGeometryOutputVertexCount: count: %d higher than maximum: %d",
+                 count, max);
+    }
+#endif
+    d_func()->geometryVertexCount = count;
+}
+
+
+/*!
+    Returns the maximum number of vertices the current geometry shader
+    program will produce, if active.
+
+    \since 4.7
+
+    This parameter takes effect the ntext time the program is linked.
+*/
+int QGLShaderProgram::geometryOutputVertexCount() const
+{
+    return d_func()->geometryVertexCount;
+}
+
+
+/*!
+    Sets the input type from \a inputType.
+
+    This parameter takes effect the next time the program is linked.
+*/
+void QGLShaderProgram::setGeometryInputType(GLenum inputType)
+{
+    d_func()->geometryInputType = inputType;
+}
+
+
+/*!
+    Returns the geometry shader input type, if active.
+
+    This parameter takes effect the next time the program is linked.
+
+    \since 4.7
+ */
+
+GLenum QGLShaderProgram::geometryInputType() const
+{
+    return d_func()->geometryInputType;
+}
+
+
+/*!
+    Sets the output type from the geometry shader, if active, to
+    \a outputType.
+
+    This parameter takes effect the next time the program is linked.
+
+    \since 4.7
+*/
+void QGLShaderProgram::setGeometryOutputType(GLenum outputType)
+{
+    d_func()->geometryOutputType = outputType;
+}
+
+
+/*!
+    Returns the geometry shader output type, if active.
+
+    This parameter takes effect the next time the program is linked.
+
+    \since 4.7
+ */
+GLenum QGLShaderProgram::geometryOutputType() const
+{
+    return d_func()->geometryOutputType;
+}
+
+
+/*!
+    Returns true if shader programs written in the OpenGL Shading
+    Language (GLSL) are supported on this system; false otherwise.
+
+    The \a context is used to resolve the GLSL extensions.
+    If \a context is null, then QGLContext::currentContext() is used.
+*/
+bool QGLShaderProgram::hasOpenGLShaderPrograms(const QGLContext *context)
+{
+#if !defined(QT_OPENGL_ES_2)
+    if (!context)
+        context = QGLContext::currentContext();
+    if (!context)
+        return false;
+    return qt_resolve_glsl_extensions(const_cast<QGLContext *>(context));
+#else
+    Q_UNUSED(context);
+    return true;
+#endif
+}
+
+/*!
+    \internal
+*/
+void QGLShaderProgram::shaderDestroyed()
+{
+    Q_D(QGLShaderProgram);
+    QGLShader *shader = qobject_cast<QGLShader *>(sender());
+    if (shader && !d->removingShaders)
+        removeShader(shader);
+}
+
+
+#undef ctx
+#undef context
+
+/*!
+    Returns true if shader programs of type \a type are supported on
+    this system; false otherwise.
+
+    The \a context is used to resolve the GLSL extensions.
+    If \a context is null, then QGLContext::currentContext() is used.
+
+    \since 4.7
+*/
+bool QGLShader::hasOpenGLShaders(ShaderType type, const QGLContext *context)
+{
+    if (!context)
+        context = QGLContext::currentContext();
+    if (!context)
+        return false;
+
+    if ((type & ~(Geometry | Vertex | Fragment)) || type == 0)
+        return false;
+
+    bool resolved = qt_resolve_glsl_extensions(const_cast<QGLContext *>(context));
+    if (!resolved)
+        return false;
+
+    if ((type & Geometry) && !QByteArray((const char *) glGetString(GL_EXTENSIONS)).contains("GL_EXT_geometry_shader4"))
+        return false;
+
+    return true;
+}
+
+
+
+#ifdef Q_MAC_COMPAT_GL_FUNCTIONS
+/*! \internal */
+void QGLShaderProgram::setAttributeArray
+    (int location, QMacCompatGLenum type, const void *values, int tupleSize, int stride)
+{
+    setAttributeArray(location, GLenum(type), values, tupleSize, stride);
+}
+
+/*! \internal */
+void QGLShaderProgram::setAttributeArray
+    (const char *name, QMacCompatGLenum type, const void *values, int tupleSize, int stride)
+{
+    setAttributeArray(name, GLenum(type), values, tupleSize, stride);
+}
+
+/*! \internal */
+void QGLShaderProgram::setAttributeBuffer
+    (int location, QMacCompatGLenum type, int offset, int tupleSize, int stride)
+{
+    setAttributeBuffer(location, GLenum(type), offset, tupleSize, stride);
+}
+
+/*! \internal */
+void QGLShaderProgram::setAttributeBuffer
+    (const char *name, QMacCompatGLenum type, int offset, int tupleSize, int stride)
+{
+    setAttributeBuffer(name, GLenum(type), offset, tupleSize, stride);
+}
+
+/*! \internal */
+void QGLShaderProgram::setUniformValue(int location, QMacCompatGLint value)
+{
+    setUniformValue(location, GLint(value));
+}
+
+/*! \internal */
+void QGLShaderProgram::setUniformValue(int location, QMacCompatGLuint value)
+{
+    setUniformValue(location, GLuint(value));
+}
+
+/*! \internal */
+void QGLShaderProgram::setUniformValue(const char *name, QMacCompatGLint value)
+{
+    setUniformValue(name, GLint(value));
+}
+
+/*! \internal */
+void QGLShaderProgram::setUniformValue(const char *name, QMacCompatGLuint value)
+{
+    setUniformValue(name, GLuint(value));
+}
+
+/*! \internal */
+void QGLShaderProgram::setUniformValueArray(int location, const QMacCompatGLint *values, int count)
+{
+    setUniformValueArray(location, (const GLint *)values, count);
+}
+
+/*! \internal */
+void QGLShaderProgram::setUniformValueArray(int location, const QMacCompatGLuint *values, int count)
+{
+    setUniformValueArray(location, (const GLuint *)values, count);
+}
+
+/*! \internal */
+void QGLShaderProgram::setUniformValueArray(const char *name, const QMacCompatGLint *values, int count)
+{
+    setUniformValueArray(name, (const GLint *)values, count);
+}
+
+/*! \internal */
+void QGLShaderProgram::setUniformValueArray(const char *name, const QMacCompatGLuint *values, int count)
+{
+    setUniformValueArray(name, (const GLuint *)values, count);
+}
+#endif
+
+#endif // !defined(QT_OPENGL_ES_1)
+
+QT_END_NAMESPACE