Move QOpenGLPaintEngine and related classes from QtGui to QtOpenGL

Also moves the openglwindow test to the opengl folder, as it makes use of these
classes.

Task-number: QTBUG-74409
Change-Id: Id9f0013cedcc8bd1e87122c005641d7298525045
Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>

24 files changed, 8523 insertions, 3 deletions

diff --git a/src/opengl/opengl.pro b/src/opengl/opengl.pro
index a726db2be9..6c2a969820 100644
--- a/src/opengl/opengl.pro
+++ b/src/opengl/opengl.pro
@@ -10,11 +10,32 @@ qtConfig(opengl): CONFIG += opengl
 qtConfig(opengles2): CONFIG += opengles2
 
 HEADERS += \
+    qopengl2pexvertexarray_p.h \
+    qopenglcustomshaderstage_p.h \
     qopengldebug.h \
+    qopenglengineshadermanager_p.h \
+    qopenglengineshadersource_p.h \
+    qopenglgradientcache_p.h \
+    qopenglpaintdevice.h \
+    qopenglpaintdevice_p.h \
+    qopenglpaintengine_p.h \
+    qopenglshadercache_p.h \
+    qopengltexturecache_p.h \
+    qopengltextureglyphcache_p.h \
+    qopengltextureuploader_p.h \
     qopenglwindow.h \
     qtopenglglobal.h
 
 SOURCES += \
+    qopengl2pexvertexarray.cpp \
+    qopenglcustomshaderstage.cpp \
+    qopenglengineshadermanager.cpp \
+    qopenglgradientcache.cpp \
+    qopenglpaintdevice.cpp \
+    qopenglpaintengine.cpp \
+    qopengltexturecache.cpp \
+    qopengltextureglyphcache.cpp \
+    qopengltextureuploader.cpp \
     qopenglwindow.cpp \
     qopengldebug.cpp
 
diff --git a/src/opengl/qopengl2pexvertexarray.cpp b/src/opengl/qopengl2pexvertexarray.cpp
new file mode 100644
index 0000000000..df0fb764c9
--- /dev/null
+++ b/src/opengl/qopengl2pexvertexarray.cpp
@@ -0,0 +1,173 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtOpenGL module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qopengl2pexvertexarray_p.h"
+
+#include <private/qbezier_p.h>
+
+QT_BEGIN_NAMESPACE
+
+void QOpenGL2PEXVertexArray::clear()
+{
+    vertexArray.reset();
+    vertexArrayStops.reset();
+    boundingRectDirty = true;
+}
+
+
+QOpenGLRect QOpenGL2PEXVertexArray::boundingRect() const
+{
+    if (boundingRectDirty)
+        return QOpenGLRect(0.0, 0.0, 0.0, 0.0);
+    else
+        return QOpenGLRect(minX, minY, maxX, maxY);
+}
+
+void QOpenGL2PEXVertexArray::addClosingLine(int index)
+{
+    QPointF point(vertexArray.at(index));
+    if (point != QPointF(vertexArray.last()))
+        vertexArray.add(point);
+}
+
+void QOpenGL2PEXVertexArray::addCentroid(const QVectorPath &path, int subPathIndex)
+{
+    const QPointF *const points = reinterpret_cast<const QPointF *>(path.points());
+    const QPainterPath::ElementType *const elements = path.elements();
+
+    QPointF sum = points[subPathIndex];
+    int count = 1;
+
+    for (int i = subPathIndex + 1; i < path.elementCount() && (!elements || elements[i] != QPainterPath::MoveToElement); ++i) {
+        sum += points[i];
+        ++count;
+    }
+
+    const QPointF centroid = sum / qreal(count);
+    vertexArray.add(centroid);
+}
+
+void QOpenGL2PEXVertexArray::addPath(const QVectorPath &path, GLfloat curveInverseScale, bool outline)
+{
+    const QPointF* const points = reinterpret_cast<const QPointF*>(path.points());
+    const QPainterPath::ElementType* const elements = path.elements();
+
+    if (boundingRectDirty) {
+        minX = maxX = points[0].x();
+        minY = maxY = points[0].y();
+        boundingRectDirty = false;
+    }
+
+    if (!outline && !path.isConvex())
+        addCentroid(path, 0);
+
+    int lastMoveTo = vertexArray.size();
+    vertexArray.add(points[0]); // The first element is always a moveTo
+
+    do {
+        if (!elements) {
+//             qDebug("QVectorPath has no elements");
+            // If the path has a null elements pointer, the elements implicitly
+            // start with a moveTo (already added) and continue with lineTos:
+            for (int i=1; i<path.elementCount(); ++i)
+                lineToArray(points[i].x(), points[i].y());
+
+            break;
+        }
+//         qDebug("QVectorPath has element types");
+
+        for (int i=1; i<path.elementCount(); ++i) {
+            switch (elements[i]) {
+            case QPainterPath::MoveToElement:
+                if (!outline)
+                    addClosingLine(lastMoveTo);
+//                qDebug("element[%d] is a MoveToElement", i);
+                vertexArrayStops.add(vertexArray.size());
+                if (!outline) {
+                    if (!path.isConvex()) addCentroid(path, i);
+                    lastMoveTo = vertexArray.size();
+                }
+                lineToArray(points[i].x(), points[i].y()); // Add the moveTo as a new vertex
+                break;
+            case QPainterPath::LineToElement:
+//                qDebug("element[%d] is a LineToElement", i);
+                lineToArray(points[i].x(), points[i].y());
+                break;
+            case QPainterPath::CurveToElement: {
+                QBezier b = QBezier::fromPoints(*(((const QPointF *) points) + i - 1),
+                                                points[i],
+                                                points[i+1],
+                                                points[i+2]);
+                QRectF bounds = b.bounds();
+                // threshold based on same algorithm as in qtriangulatingstroker.cpp
+                int threshold = qMin<float>(64, qMax(bounds.width(), bounds.height()) * 3.14f / (curveInverseScale * 6));
+                if (threshold < 3) threshold = 3;
+                qreal one_over_threshold_minus_1 = qreal(1) / (threshold - 1);
+                for (int t=0; t<threshold; ++t) {
+                    QPointF pt = b.pointAt(t * one_over_threshold_minus_1);
+                    lineToArray(pt.x(), pt.y());
+                }
+                i += 2;
+                break; }
+            default:
+                break;
+            }
+        }
+    } while (0);
+
+    if (!outline)
+        addClosingLine(lastMoveTo);
+    vertexArrayStops.add(vertexArray.size());
+}
+
+void QOpenGL2PEXVertexArray::lineToArray(const GLfloat x, const GLfloat y)
+{
+    vertexArray.add(QOpenGLPoint(x, y));
+
+    if (x > maxX)
+        maxX = x;
+    else if (x < minX)
+        minX = x;
+    if (y > maxY)
+        maxY = y;
+    else if (y < minY)
+        minY = y;
+}
+
+QT_END_NAMESPACE
diff --git a/src/opengl/qopengl2pexvertexarray_p.h b/src/opengl/qopengl2pexvertexarray_p.h
new file mode 100644
index 0000000000..3ef26e908d
--- /dev/null
+++ b/src/opengl/qopengl2pexvertexarray_p.h
@@ -0,0 +1,167 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtOpenGL module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#ifndef QOPENGL2PEXVERTEXARRAY_P_H
+#define QOPENGL2PEXVERTEXARRAY_P_H
+
+#include <QRectF>
+
+#include <private/qdatabuffer_p.h>
+#include <private/qvectorpath_p.h>
+#include <private/qopenglcontext_p.h>
+
+QT_BEGIN_NAMESPACE
+
+class QOpenGLPoint
+{
+public:
+    QOpenGLPoint(GLfloat new_x, GLfloat new_y) :
+        x(new_x), y(new_y) {};
+
+    QOpenGLPoint(const QPointF &p) :
+        x(p.x()), y(p.y()) {};
+
+    QOpenGLPoint(const QPointF* p) :
+        x(p->x()), y(p->y()) {};
+
+    GLfloat x;
+    GLfloat y;
+
+    operator QPointF() {return QPointF(x,y);}
+    operator QPointF() const {return QPointF(x,y);}
+};
+
+struct QOpenGLRect
+{
+    QOpenGLRect(const QRectF &r)
+        :  left(r.left()), top(r.top()), right(r.right()), bottom(r.bottom()) {}
+
+    QOpenGLRect(GLfloat l, GLfloat t, GLfloat r, GLfloat b)
+        : left(l), top(t), right(r), bottom(b) {}
+
+    GLfloat left;
+    GLfloat top;
+    GLfloat right;
+    GLfloat bottom;
+
+    operator QRectF() const {return QRectF(left, top, right-left, bottom-top);}
+};
+
+class QOpenGL2PEXVertexArray
+{
+public:
+    QOpenGL2PEXVertexArray() :
+        vertexArray(0), vertexArrayStops(0),
+        maxX(-2e10), maxY(-2e10), minX(2e10), minY(2e10),
+        boundingRectDirty(true)
+    { }
+
+    inline void addRect(const QRectF &rect)
+    {
+        qreal top = rect.top();
+        qreal left = rect.left();
+        qreal bottom = rect.bottom();
+        qreal right = rect.right();
+
+        vertexArray << QOpenGLPoint(left, top)
+                    << QOpenGLPoint(right, top)
+                    << QOpenGLPoint(right, bottom)
+                    << QOpenGLPoint(right, bottom)
+                    << QOpenGLPoint(left, bottom)
+                    << QOpenGLPoint(left, top);
+    }
+
+    inline void addQuad(const QRectF &rect)
+    {
+        qreal top = rect.top();
+        qreal left = rect.left();
+        qreal bottom = rect.bottom();
+        qreal right = rect.right();
+
+        vertexArray << QOpenGLPoint(left, top)
+                    << QOpenGLPoint(right, top)
+                    << QOpenGLPoint(left, bottom)
+                    << QOpenGLPoint(right, bottom);
+
+    }
+
+    inline void addVertex(const GLfloat x, const GLfloat y)
+    {
+        vertexArray.add(QOpenGLPoint(x, y));
+    }
+
+    void addPath(const QVectorPath &path, GLfloat curveInverseScale, bool outline = true);
+    void clear();
+
+    QOpenGLPoint*        data() {return vertexArray.data();}
+    int *stops() const { return vertexArrayStops.data(); }
+    int stopCount() const { return vertexArrayStops.size(); }
+    QOpenGLRect         boundingRect() const;
+
+    int vertexCount() const { return vertexArray.size(); }
+
+    void lineToArray(const GLfloat x, const GLfloat y);
+
+private:
+    QDataBuffer<QOpenGLPoint> vertexArray;
+    QDataBuffer<int>      vertexArrayStops;
+
+    GLfloat     maxX;
+    GLfloat     maxY;
+    GLfloat     minX;
+    GLfloat     minY;
+    bool        boundingRectDirty;
+    void addClosingLine(int index);
+    void addCentroid(const QVectorPath &path, int subPathIndex);
+};
+
+QT_END_NAMESPACE
+
+#endif
diff --git a/src/opengl/qopenglcustomshaderstage.cpp b/src/opengl/qopenglcustomshaderstage.cpp
new file mode 100644
index 0000000000..7a32b2fbc0
--- /dev/null
+++ b/src/opengl/qopenglcustomshaderstage.cpp
@@ -0,0 +1,137 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtOpenGL module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qopenglcustomshaderstage_p.h"
+#include "qopenglengineshadermanager_p.h"
+#include "qopenglpaintengine_p.h"
+#include <private/qpainter_p.h>
+
+QT_BEGIN_NAMESPACE
+
+class QOpenGLCustomShaderStagePrivate
+{
+public:
+    QOpenGLCustomShaderStagePrivate() :
+        m_manager(nullptr) {}
+
+    QPointer<QOpenGLEngineShaderManager> m_manager;
+    QByteArray              m_source;
+};
+
+
+
+
+QOpenGLCustomShaderStage::QOpenGLCustomShaderStage()
+    : d_ptr(new QOpenGLCustomShaderStagePrivate)
+{
+}
+
+QOpenGLCustomShaderStage::~QOpenGLCustomShaderStage()
+{
+    Q_D(QOpenGLCustomShaderStage);
+    if (d->m_manager) {
+        d->m_manager->removeCustomStage();
+        d->m_manager->sharedShaders->cleanupCustomStage(this);
+    }
+    delete d_ptr;
+}
+
+void QOpenGLCustomShaderStage::setUniformsDirty()
+{
+    Q_D(QOpenGLCustomShaderStage);
+    if (d->m_manager)
+        d->m_manager->setDirty(); // ### Probably a bit overkill!
+}
+
+bool QOpenGLCustomShaderStage::setOnPainter(QPainter* p)
+{
+    Q_D(QOpenGLCustomShaderStage);
+    if (p->paintEngine()->type() != QPaintEngine::OpenGL2) {
+        qWarning("QOpenGLCustomShaderStage::setOnPainter() - paint engine not OpenGL2");
+        return false;
+    }
+    if (d->m_manager)
+        qWarning("Custom shader is already set on a painter");
+
+    QOpenGL2PaintEngineEx *engine = static_cast<QOpenGL2PaintEngineEx*>(p->paintEngine());
+    d->m_manager = QOpenGL2PaintEngineExPrivate::shaderManagerForEngine(engine);
+    Q_ASSERT(d->m_manager);
+
+    d->m_manager->setCustomStage(this);
+    return true;
+}
+
+void QOpenGLCustomShaderStage::removeFromPainter(QPainter* p)
+{
+    Q_D(QOpenGLCustomShaderStage);
+    if (p->paintEngine()->type() != QPaintEngine::OpenGL2)
+        return;
+
+    QOpenGL2PaintEngineEx *engine = static_cast<QOpenGL2PaintEngineEx*>(p->paintEngine());
+    d->m_manager = QOpenGL2PaintEngineExPrivate::shaderManagerForEngine(engine);
+    Q_ASSERT(d->m_manager);
+
+    // Just set the stage to null, don't call removeCustomStage().
+    // This should leave the program in a compiled/linked state
+    // if the next custom shader stage is this one again.
+    d->m_manager->setCustomStage(nullptr);
+    d->m_manager = nullptr;
+}
+
+QByteArray QOpenGLCustomShaderStage::source() const
+{
+    Q_D(const QOpenGLCustomShaderStage);
+    return d->m_source;
+}
+
+// Called by the shader manager if another custom shader is attached or
+// the manager is deleted
+void QOpenGLCustomShaderStage::setInactive()
+{
+    Q_D(QOpenGLCustomShaderStage);
+    d->m_manager = nullptr;
+}
+
+void QOpenGLCustomShaderStage::setSource(const QByteArray& s)
+{
+    Q_D(QOpenGLCustomShaderStage);
+    d->m_source = s;
+}
+
+QT_END_NAMESPACE
diff --git a/src/opengl/qopenglcustomshaderstage_p.h b/src/opengl/qopenglcustomshaderstage_p.h
new file mode 100644
index 0000000000..255c115e3c
--- /dev/null
+++ b/src/opengl/qopenglcustomshaderstage_p.h
@@ -0,0 +1,90 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtOpenGL module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QOPENGL_CUSTOM_SHADER_STAGE_H
+#define QOPENGL_CUSTOM_SHADER_STAGE_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QtOpenGL/qtopenglglobal.h>
+#include <QOpenGLShaderProgram>
+
+QT_BEGIN_NAMESPACE
+
+
+class QPainter;
+class QOpenGLCustomShaderStagePrivate;
+class Q_OPENGL_EXPORT QOpenGLCustomShaderStage
+{
+    Q_DECLARE_PRIVATE(QOpenGLCustomShaderStage)
+public:
+    QOpenGLCustomShaderStage();
+    virtual ~QOpenGLCustomShaderStage();
+    virtual void setUniforms(QOpenGLShaderProgram*) {}
+
+    void setUniformsDirty();
+
+    bool setOnPainter(QPainter*);
+    void removeFromPainter(QPainter*);
+    QByteArray source() const;
+
+    void setInactive();
+protected:
+    void setSource(const QByteArray&);
+
+private:
+    QOpenGLCustomShaderStagePrivate* d_ptr;
+
+    Q_DISABLE_COPY_MOVE(QOpenGLCustomShaderStage)
+};
+
+
+QT_END_NAMESPACE
+
+
+#endif
diff --git a/src/opengl/qopenglengineshadermanager.cpp b/src/opengl/qopenglengineshadermanager.cpp
new file mode 100644
index 0000000000..09bd9ff096
--- /dev/null
+++ b/src/opengl/qopenglengineshadermanager.cpp
@@ -0,0 +1,898 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtOpenGL module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qopenglengineshadermanager_p.h"
+#include "qopenglengineshadersource_p.h"
+#include "qopenglpaintengine_p.h"
+#include <private/qopenglshadercache_p.h>
+
+#include <QtGui/private/qopenglcontext_p.h>
+#include <QtCore/qthreadstorage.h>
+
+#include <algorithm>
+
+#if defined(QT_DEBUG)
+#include <QMetaEnum>
+#endif
+
+// #define QT_GL_SHARED_SHADER_DEBUG
+
+QT_BEGIN_NAMESPACE
+
+class QOpenGLEngineSharedShadersResource : public QOpenGLSharedResource
+{
+public:
+    QOpenGLEngineSharedShadersResource(QOpenGLContext *ctx)
+        : QOpenGLSharedResource(ctx->shareGroup())
+        , m_shaders(new QOpenGLEngineSharedShaders(ctx))
+    {
+    }
+
+    ~QOpenGLEngineSharedShadersResource()
+    {
+        delete m_shaders;
+    }
+
+    void invalidateResource() override
+    {
+        delete m_shaders;
+        m_shaders = nullptr;
+    }
+
+    void freeResource(QOpenGLContext *) override
+    {
+    }
+
+    QOpenGLEngineSharedShaders *shaders() const { return m_shaders; }
+
+private:
+    QOpenGLEngineSharedShaders *m_shaders;
+};
+
+class QOpenGLShaderStorage
+{
+public:
+    QOpenGLEngineSharedShaders *shadersForThread(QOpenGLContext *context) {
+        QOpenGLMultiGroupSharedResource *&shaders = m_storage.localData();
+        if (!shaders)
+            shaders = new QOpenGLMultiGroupSharedResource;
+        QOpenGLEngineSharedShadersResource *resource =
+            shaders->value<QOpenGLEngineSharedShadersResource>(context);
+        return resource ? resource->shaders() : nullptr;
+    }
+
+private:
+    QThreadStorage<QOpenGLMultiGroupSharedResource *> m_storage;
+};
+
+Q_GLOBAL_STATIC(QOpenGLShaderStorage, qt_shader_storage);
+
+QOpenGLEngineSharedShaders *QOpenGLEngineSharedShaders::shadersForContext(QOpenGLContext *context)
+{
+    return qt_shader_storage()->shadersForThread(context);
+}
+
+const char* QOpenGLEngineSharedShaders::qShaderSnippets[] = {
+    0,0,0,0,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,0,0,
+    0,0,0,0,0
+};
+
+QOpenGLEngineSharedShaders::QOpenGLEngineSharedShaders(QOpenGLContext* context)
+    : blitShaderProg(nullptr)
+    , simpleShaderProg(nullptr)
+{
+
+/*
+    Rather than having the shader source array statically initialised, it is initialised
+    here instead. This is to allow new shader names to be inserted or existing names moved
+    around without having to change the order of the glsl strings. It is hoped this will
+    make future hard-to-find runtime bugs more obvious and generally give more solid code.
+*/
+
+    // Check if the user has requested an OpenGL 3.2 Core Profile or higher
+    // and if so use GLSL 1.50 core shaders instead of legacy ones.
+    const QSurfaceFormat &fmt = context->format();
+    const bool isCoreProfile = fmt.profile() == QSurfaceFormat::CoreProfile && fmt.version() >= qMakePair(3,2);
+
+    const char** code = qShaderSnippets; // shortcut
+
+    if (isCoreProfile) {
+        code[MainVertexShader] = qopenglslMainVertexShader_core;
+        code[MainWithTexCoordsVertexShader] = qopenglslMainWithTexCoordsVertexShader_core;
+        code[MainWithTexCoordsAndOpacityVertexShader] = qopenglslMainWithTexCoordsAndOpacityVertexShader_core;
+
+        code[UntransformedPositionVertexShader] = qopenglslUntransformedPositionVertexShader_core;
+        code[PositionOnlyVertexShader] = qopenglslPositionOnlyVertexShader_core;
+        code[ComplexGeometryPositionOnlyVertexShader] = qopenglslComplexGeometryPositionOnlyVertexShader_core;
+        code[PositionWithPatternBrushVertexShader] = qopenglslPositionWithPatternBrushVertexShader_core;
+        code[PositionWithLinearGradientBrushVertexShader] = qopenglslPositionWithLinearGradientBrushVertexShader_core;
+        code[PositionWithConicalGradientBrushVertexShader] = qopenglslPositionWithConicalGradientBrushVertexShader_core;
+        code[PositionWithRadialGradientBrushVertexShader] = qopenglslPositionWithRadialGradientBrushVertexShader_core;
+        code[PositionWithTextureBrushVertexShader] = qopenglslPositionWithTextureBrushVertexShader_core;
+        code[AffinePositionWithPatternBrushVertexShader] = qopenglslAffinePositionWithPatternBrushVertexShader_core;
+        code[AffinePositionWithLinearGradientBrushVertexShader] = qopenglslAffinePositionWithLinearGradientBrushVertexShader_core;
+        code[AffinePositionWithConicalGradientBrushVertexShader] = qopenglslAffinePositionWithConicalGradientBrushVertexShader_core;
+        code[AffinePositionWithRadialGradientBrushVertexShader] = qopenglslAffinePositionWithRadialGradientBrushVertexShader_core;
+        code[AffinePositionWithTextureBrushVertexShader] = qopenglslAffinePositionWithTextureBrushVertexShader_core;
+
+        code[MainFragmentShader_MO] = qopenglslMainFragmentShader_MO_core;
+        code[MainFragmentShader_M] = qopenglslMainFragmentShader_M_core;
+        code[MainFragmentShader_O] = qopenglslMainFragmentShader_O_core;
+        code[MainFragmentShader] = qopenglslMainFragmentShader_core;
+        code[MainFragmentShader_ImageArrays] = qopenglslMainFragmentShader_ImageArrays_core;
+
+        code[ImageSrcFragmentShader] = qopenglslImageSrcFragmentShader_core;
+        code[ImageSrcWithPatternFragmentShader] = qopenglslImageSrcWithPatternFragmentShader_core;
+        code[NonPremultipliedImageSrcFragmentShader] = qopenglslNonPremultipliedImageSrcFragmentShader_core;
+        code[GrayscaleImageSrcFragmentShader] = qopenglslGrayscaleImageSrcFragmentShader_core;
+        code[AlphaImageSrcFragmentShader] = qopenglslAlphaImageSrcFragmentShader_core;
+        code[CustomImageSrcFragmentShader] = qopenglslCustomSrcFragmentShader_core; // Calls "customShader", which must be appended
+        code[SolidBrushSrcFragmentShader] = qopenglslSolidBrushSrcFragmentShader_core;
+
+        code[TextureBrushSrcFragmentShader] = qopenglslTextureBrushSrcFragmentShader_core;
+        code[TextureBrushSrcWithPatternFragmentShader] = qopenglslTextureBrushSrcWithPatternFragmentShader_core;
+        code[PatternBrushSrcFragmentShader] = qopenglslPatternBrushSrcFragmentShader_core;
+        code[LinearGradientBrushSrcFragmentShader] = qopenglslLinearGradientBrushSrcFragmentShader_core;
+        code[RadialGradientBrushSrcFragmentShader] = qopenglslRadialGradientBrushSrcFragmentShader_core;
+        code[ConicalGradientBrushSrcFragmentShader] = qopenglslConicalGradientBrushSrcFragmentShader_core;
+        code[ShockingPinkSrcFragmentShader] = qopenglslShockingPinkSrcFragmentShader_core;
+
+        code[NoMaskFragmentShader] = "";
+        code[MaskFragmentShader] = qopenglslMaskFragmentShader_core;
+        code[RgbMaskFragmentShaderPass1] = qopenglslRgbMaskFragmentShaderPass1_core;
+        code[RgbMaskFragmentShaderPass2] = qopenglslRgbMaskFragmentShaderPass2_core;
+        code[RgbMaskWithGammaFragmentShader] = ""; //###
+    } else {
+        code[MainVertexShader] = qopenglslMainVertexShader;
+        code[MainWithTexCoordsVertexShader] = qopenglslMainWithTexCoordsVertexShader;
+        code[MainWithTexCoordsAndOpacityVertexShader] = qopenglslMainWithTexCoordsAndOpacityVertexShader;
+
+        code[UntransformedPositionVertexShader] = qopenglslUntransformedPositionVertexShader;
+        code[PositionOnlyVertexShader] = qopenglslPositionOnlyVertexShader;
+        code[ComplexGeometryPositionOnlyVertexShader] = qopenglslComplexGeometryPositionOnlyVertexShader;
+        code[PositionWithPatternBrushVertexShader] = qopenglslPositionWithPatternBrushVertexShader;
+        code[PositionWithLinearGradientBrushVertexShader] = qopenglslPositionWithLinearGradientBrushVertexShader;
+        code[PositionWithConicalGradientBrushVertexShader] = qopenglslPositionWithConicalGradientBrushVertexShader;
+        code[PositionWithRadialGradientBrushVertexShader] = qopenglslPositionWithRadialGradientBrushVertexShader;
+        code[PositionWithTextureBrushVertexShader] = qopenglslPositionWithTextureBrushVertexShader;
+        code[AffinePositionWithPatternBrushVertexShader] = qopenglslAffinePositionWithPatternBrushVertexShader;
+        code[AffinePositionWithLinearGradientBrushVertexShader] = qopenglslAffinePositionWithLinearGradientBrushVertexShader;
+        code[AffinePositionWithConicalGradientBrushVertexShader] = qopenglslAffinePositionWithConicalGradientBrushVertexShader;
+        code[AffinePositionWithRadialGradientBrushVertexShader] = qopenglslAffinePositionWithRadialGradientBrushVertexShader;
+        code[AffinePositionWithTextureBrushVertexShader] = qopenglslAffinePositionWithTextureBrushVertexShader;
+
+        code[MainFragmentShader_MO] = qopenglslMainFragmentShader_MO;
+        code[MainFragmentShader_M] = qopenglslMainFragmentShader_M;
+        code[MainFragmentShader_O] = qopenglslMainFragmentShader_O;
+        code[MainFragmentShader] = qopenglslMainFragmentShader;
+        code[MainFragmentShader_ImageArrays] = qopenglslMainFragmentShader_ImageArrays;
+
+        code[ImageSrcFragmentShader] = qopenglslImageSrcFragmentShader;
+        code[ImageSrcWithPatternFragmentShader] = qopenglslImageSrcWithPatternFragmentShader;
+        code[NonPremultipliedImageSrcFragmentShader] = qopenglslNonPremultipliedImageSrcFragmentShader;
+        code[GrayscaleImageSrcFragmentShader] = qopenglslGrayscaleImageSrcFragmentShader;
+        code[AlphaImageSrcFragmentShader] = qopenglslAlphaImageSrcFragmentShader;
+        code[CustomImageSrcFragmentShader] = qopenglslCustomSrcFragmentShader; // Calls "customShader", which must be appended
+        code[SolidBrushSrcFragmentShader] = qopenglslSolidBrushSrcFragmentShader;
+        code[TextureBrushSrcFragmentShader] = qopenglslTextureBrushSrcFragmentShader;
+        code[TextureBrushSrcWithPatternFragmentShader] = qopenglslTextureBrushSrcWithPatternFragmentShader;
+        code[PatternBrushSrcFragmentShader] = qopenglslPatternBrushSrcFragmentShader;
+        code[LinearGradientBrushSrcFragmentShader] = qopenglslLinearGradientBrushSrcFragmentShader;
+        code[RadialGradientBrushSrcFragmentShader] = qopenglslRadialGradientBrushSrcFragmentShader;
+        code[ConicalGradientBrushSrcFragmentShader] = qopenglslConicalGradientBrushSrcFragmentShader;
+        code[ShockingPinkSrcFragmentShader] = qopenglslShockingPinkSrcFragmentShader;
+
+        code[NoMaskFragmentShader] = "";
+        code[MaskFragmentShader] = qopenglslMaskFragmentShader;
+        code[RgbMaskFragmentShaderPass1] = qopenglslRgbMaskFragmentShaderPass1;
+        code[RgbMaskFragmentShaderPass2] = qopenglslRgbMaskFragmentShaderPass2;
+        code[RgbMaskWithGammaFragmentShader] = ""; //###
+    }
+
+    // The composition shaders are just layout qualifiers and the same
+    // for all profiles that support them.
+    code[NoCompositionModeFragmentShader] = "";
+    code[MultiplyCompositionModeFragmentShader] = qopenglslMultiplyCompositionModeFragmentShader;
+    code[ScreenCompositionModeFragmentShader] = qopenglslScreenCompositionModeFragmentShader;
+    code[OverlayCompositionModeFragmentShader] = qopenglslOverlayCompositionModeFragmentShader;
+    code[DarkenCompositionModeFragmentShader] = qopenglslDarkenCompositionModeFragmentShader;
+    code[LightenCompositionModeFragmentShader] = qopenglslLightenCompositionModeFragmentShader;
+    code[ColorDodgeCompositionModeFragmentShader] = qopenglslColorDodgeCompositionModeFragmentShader;
+    code[ColorBurnCompositionModeFragmentShader] = qopenglslColorBurnCompositionModeFragmentShader;
+    code[HardLightCompositionModeFragmentShader] = qopenglslHardLightCompositionModeFragmentShader;
+    code[SoftLightCompositionModeFragmentShader] = qopenglslSoftLightCompositionModeFragmentShader;
+    code[DifferenceCompositionModeFragmentShader] = qopenglslDifferenceCompositionModeFragmentShader;
+    code[ExclusionCompositionModeFragmentShader] = qopenglslExclusionCompositionModeFragmentShader;
+
+#if defined(QT_DEBUG)
+    // Check that all the elements have been filled:
+    for (int i = 0; i < TotalSnippetCount; ++i) {
+        if (Q_UNLIKELY(!qShaderSnippets[i])) {
+            qFatal("Shader snippet for %s (#%d) is missing!",
+                   snippetNameStr(SnippetName(i)).constData(), i);
+        }
+    }
+#endif
+
+    QByteArray vertexSource;
+    QByteArray fragSource;
+
+    // Compile up the simple shader:
+#ifdef Q_OS_WASM
+    vertexSource.append(qShaderSnippets[PositionOnlyVertexShader]);
+    vertexSource.append(qShaderSnippets[MainVertexShader]);
+#else
+    vertexSource.append(qShaderSnippets[MainVertexShader]);
+    vertexSource.append(qShaderSnippets[PositionOnlyVertexShader]);
+#endif
+    fragSource.append(qShaderSnippets[MainFragmentShader]);
+    fragSource.append(qShaderSnippets[ShockingPinkSrcFragmentShader]);
+
+    simpleShaderProg = new QOpenGLShaderProgram;
+
+    CachedShader simpleShaderCache(fragSource, vertexSource);
+
+    bool inCache = simpleShaderCache.load(simpleShaderProg, context);
+
+    if (!inCache) {
+        if (!simpleShaderProg->addCacheableShaderFromSourceCode(QOpenGLShader::Vertex, vertexSource))
+            qWarning("Vertex shader for simpleShaderProg (MainVertexShader & PositionOnlyVertexShader) failed to compile");
+        if (!simpleShaderProg->addCacheableShaderFromSourceCode(QOpenGLShader::Fragment, fragSource))
+            qWarning("Fragment shader for simpleShaderProg (MainFragmentShader & ShockingPinkSrcFragmentShader) failed to compile");
+
+        simpleShaderProg->bindAttributeLocation("vertexCoordsArray", QT_VERTEX_COORDS_ATTR);
+        simpleShaderProg->bindAttributeLocation("pmvMatrix1", QT_PMV_MATRIX_1_ATTR);
+        simpleShaderProg->bindAttributeLocation("pmvMatrix2", QT_PMV_MATRIX_2_ATTR);
+        simpleShaderProg->bindAttributeLocation("pmvMatrix3", QT_PMV_MATRIX_3_ATTR);
+    }
+
+    simpleShaderProg->link();
+
+    if (Q_UNLIKELY(!simpleShaderProg->isLinked())) {
+        qCritical("Errors linking simple shader: %s", qPrintable(simpleShaderProg->log()));
+    } else {
+        if (!inCache)
+            simpleShaderCache.store(simpleShaderProg, context);
+    }
+
+    // Compile the blit shader:
+    vertexSource.clear();
+    vertexSource.append(qShaderSnippets[MainWithTexCoordsVertexShader]);
+    vertexSource.append(qShaderSnippets[UntransformedPositionVertexShader]);
+
+    fragSource.clear();
+    fragSource.append(qShaderSnippets[MainFragmentShader]);
+    fragSource.append(qShaderSnippets[ImageSrcFragmentShader]);
+
+    blitShaderProg = new QOpenGLShaderProgram;
+
+    CachedShader blitShaderCache(fragSource, vertexSource);
+
+    inCache = blitShaderCache.load(blitShaderProg, context);
+
+    if (!inCache) {
+        if (!blitShaderProg->addCacheableShaderFromSourceCode(QOpenGLShader::Vertex, vertexSource))
+            qWarning("Vertex shader for blitShaderProg (MainWithTexCoordsVertexShader & UntransformedPositionVertexShader) failed to compile");
+        if (!blitShaderProg->addCacheableShaderFromSourceCode(QOpenGLShader::Fragment, fragSource))
+            qWarning("Fragment shader for blitShaderProg (MainFragmentShader & ImageSrcFragmentShader) failed to compile");
+
+        blitShaderProg->bindAttributeLocation("textureCoordArray", QT_TEXTURE_COORDS_ATTR);
+        blitShaderProg->bindAttributeLocation("vertexCoordsArray", QT_VERTEX_COORDS_ATTR);
+    }
+
+    blitShaderProg->link();
+    if (Q_UNLIKELY(!blitShaderProg->isLinked())) {
+        qCritical("Errors linking blit shader: %s", qPrintable(blitShaderProg->log()));
+    } else {
+        if (!inCache)
+            blitShaderCache.store(blitShaderProg, context);
+    }
+
+#ifdef QT_GL_SHARED_SHADER_DEBUG
+    qDebug(" -> QOpenGLEngineSharedShaders() %p for thread %p.", this, QThread::currentThread());
+#endif
+}
+
+QOpenGLEngineSharedShaders::~QOpenGLEngineSharedShaders()
+{
+#ifdef QT_GL_SHARED_SHADER_DEBUG
+    qDebug(" -> ~QOpenGLEngineSharedShaders() %p for thread %p.", this, QThread::currentThread());
+#endif
+    qDeleteAll(cachedPrograms);
+    cachedPrograms.clear();
+
+    if (blitShaderProg) {
+        delete blitShaderProg;
+        blitShaderProg = nullptr;
+    }
+
+    if (simpleShaderProg) {
+        delete simpleShaderProg;
+        simpleShaderProg = nullptr;
+    }
+}
+
+#if defined (QT_DEBUG)
+QByteArray QOpenGLEngineSharedShaders::snippetNameStr(SnippetName name)
+{
+    QMetaEnum m = staticMetaObject.enumerator(staticMetaObject.indexOfEnumerator("SnippetName"));
+    return QByteArray(m.valueToKey(name));
+}
+#endif
+
+// The address returned here will only be valid until next time this function is called.
+// The program is return bound.
+QOpenGLEngineShaderProg *QOpenGLEngineSharedShaders::findProgramInCache(const QOpenGLEngineShaderProg &prog)
+{
+    for (int i = 0; i < cachedPrograms.size(); ++i) {
+        QOpenGLEngineShaderProg *cachedProg = cachedPrograms[i];
+        if (*cachedProg == prog) {
+            // Move the program to the top of the list as a poor-man's cache algo
+            cachedPrograms.move(i, 0);
+            cachedProg->program->bind();
+            return cachedProg;
+        }
+    }
+
+    QScopedPointer<QOpenGLEngineShaderProg> newProg;
+
+    do {
+        QByteArray fragSource;
+        // Insert the custom stage before the srcPixel shader to work around an ATI driver bug
+        // where you cannot forward declare a function that takes a sampler as argument.
+        if (prog.srcPixelFragShader == CustomImageSrcFragmentShader)
+            fragSource.append(prog.customStageSource);
+        fragSource.append(qShaderSnippets[prog.mainFragShader]);
+        fragSource.append(qShaderSnippets[prog.srcPixelFragShader]);
+        if (prog.compositionFragShader)
+            fragSource.append(qShaderSnippets[prog.compositionFragShader]);
+        if (prog.maskFragShader)
+            fragSource.append(qShaderSnippets[prog.maskFragShader]);
+
+        QByteArray vertexSource;
+#ifdef Q_OS_WASM
+        vertexSource.append(qShaderSnippets[prog.positionVertexShader]);
+        vertexSource.append(qShaderSnippets[prog.mainVertexShader]);
+#else
+        vertexSource.append(qShaderSnippets[prog.mainVertexShader]);
+        vertexSource.append(qShaderSnippets[prog.positionVertexShader]);
+#endif
+        QScopedPointer<QOpenGLShaderProgram> shaderProgram(new QOpenGLShaderProgram);
+
+        CachedShader shaderCache(fragSource, vertexSource);
+        bool inCache = shaderCache.load(shaderProgram.data(), QOpenGLContext::currentContext());
+
+        if (!inCache) {
+            if (!shaderProgram->addCacheableShaderFromSourceCode(QOpenGLShader::Vertex, vertexSource)) {
+                QByteArray description;
+#if defined(QT_DEBUG)
+                description.append("Vertex shader: main=");
+                description.append(snippetNameStr(prog.mainVertexShader));
+                description.append(", position=");
+                description.append(snippetNameStr(prog.positionVertexShader));
+#endif
+                qWarning("Warning: \"%s\" failed to compile!", description.constData());
+                break;
+            }
+            if (!shaderProgram->addCacheableShaderFromSourceCode(QOpenGLShader::Fragment, fragSource)) {
+                QByteArray description;
+#if defined(QT_DEBUG)
+                description.append("Fragment shader: main=");
+                description.append(snippetNameStr(prog.mainFragShader));
+                description.append(", srcPixel=");
+                description.append(snippetNameStr(prog.srcPixelFragShader));
+                if (prog.compositionFragShader) {
+                    description.append(", composition=");
+                    description.append(snippetNameStr(prog.compositionFragShader));
+                }
+                if (prog.maskFragShader) {
+                    description.append(", mask=");
+                    description.append(snippetNameStr(prog.maskFragShader));
+                }
+#endif
+                qWarning("Warning: \"%s\" failed to compile!", description.constData());
+                break;
+            }
+
+            // We have to bind the vertex attribute names before the program is linked:
+            shaderProgram->bindAttributeLocation("vertexCoordsArray", QT_VERTEX_COORDS_ATTR);
+            if (prog.useTextureCoords)
+                shaderProgram->bindAttributeLocation("textureCoordArray", QT_TEXTURE_COORDS_ATTR);
+            if (prog.useOpacityAttribute)
+                shaderProgram->bindAttributeLocation("opacityArray", QT_OPACITY_ATTR);
+            if (prog.usePmvMatrixAttribute) {
+                shaderProgram->bindAttributeLocation("pmvMatrix1", QT_PMV_MATRIX_1_ATTR);
+                shaderProgram->bindAttributeLocation("pmvMatrix2", QT_PMV_MATRIX_2_ATTR);
+                shaderProgram->bindAttributeLocation("pmvMatrix3", QT_PMV_MATRIX_3_ATTR);
+            }
+        }
+
+        newProg.reset(new QOpenGLEngineShaderProg(prog));
+        newProg->program = shaderProgram.take();
+
+        newProg->program->link();
+        if (newProg->program->isLinked()) {
+            if (!inCache)
+                shaderCache.store(newProg->program, QOpenGLContext::currentContext());
+        } else {
+            QString error;
+            error = QLatin1String("Shader program failed to link")
+                    + QLatin1String("  Error Log:\n")
+                    + QLatin1String("    ") + newProg->program->log();
+            qWarning() << error;
+            break;
+        }
+
+        newProg->program->bind();
+
+        if (newProg->maskFragShader != QOpenGLEngineSharedShaders::NoMaskFragmentShader) {
+            GLuint location = newProg->program->uniformLocation("maskTexture");
+            newProg->program->setUniformValue(location, QT_MASK_TEXTURE_UNIT);
+        }
+
+        if (cachedPrograms.count() > 30) {
+            // The cache is full, so delete the last 5 programs in the list.
+            // These programs will be least used, as a program us bumped to
+            // the top of the list when it's used.
+            for (int i = 0; i < 5; ++i) {
+                delete cachedPrograms.last();
+                cachedPrograms.removeLast();
+            }
+        }
+
+        cachedPrograms.insert(0, newProg.data());
+    } while (false);
+
+    return newProg.take();
+}
+
+void QOpenGLEngineSharedShaders::cleanupCustomStage(QOpenGLCustomShaderStage* stage)
+{
+    auto hasStageAsCustomShaderSouce = [stage](QOpenGLEngineShaderProg *cachedProg) -> bool {
+        if (cachedProg->customStageSource == stage->source()) {
+            delete cachedProg;
+            return true;
+        }
+        return false;
+    };
+    cachedPrograms.erase(std::remove_if(cachedPrograms.begin(), cachedPrograms.end(),
+                                        hasStageAsCustomShaderSouce),
+                         cachedPrograms.end());
+}
+
+
+QOpenGLEngineShaderManager::QOpenGLEngineShaderManager(QOpenGLContext* context)
+    : ctx(context),
+      shaderProgNeedsChanging(true),
+      complexGeometry(false),
+      srcPixelType(Qt::NoBrush),
+      opacityMode(NoOpacity),
+      maskType(NoMask),
+      compositionMode(QPainter::CompositionMode_SourceOver),
+      customSrcStage(nullptr),
+      currentShaderProg(nullptr)
+{
+    sharedShaders = QOpenGLEngineSharedShaders::shadersForContext(context);
+}
+
+QOpenGLEngineShaderManager::~QOpenGLEngineShaderManager()
+{
+    //###
+    removeCustomStage();
+}
+
+GLuint QOpenGLEngineShaderManager::getUniformLocation(Uniform id)
+{
+    if (!currentShaderProg)
+        return 0;
+
+    QVector<uint> &uniformLocations = currentShaderProg->uniformLocations;
+    if (uniformLocations.isEmpty())
+        uniformLocations.fill(GLuint(-1), NumUniforms);
+
+    const char uniformNames[][26] = {
+        "imageTexture",
+        "patternColor",
+        "globalOpacity",
+        "depth",
+        "maskTexture",
+        "fragmentColor",
+        "linearData",
+        "angle",
+        "halfViewportSize",
+        "fmp",
+        "fmp2_m_radius2",
+        "inverse_2_fmp2_m_radius2",
+        "sqrfr",
+        "bradius",
+        "invertedTextureSize",
+        "brushTransform",
+        "brushTexture",
+        "matrix"
+    };
+
+    if (uniformLocations.at(id) == GLuint(-1))
+        uniformLocations[id] = currentShaderProg->program->uniformLocation(uniformNames[id]);
+
+    return uniformLocations.at(id);
+}
+
+
+void QOpenGLEngineShaderManager::optimiseForBrushTransform(QTransform::TransformationType transformType)
+{
+    Q_UNUSED(transformType); // Currently ignored
+}
+
+void QOpenGLEngineShaderManager::setDirty()
+{
+    shaderProgNeedsChanging = true;
+}
+
+void QOpenGLEngineShaderManager::setSrcPixelType(Qt::BrushStyle style)
+{
+    Q_ASSERT(style != Qt::NoBrush);
+    if (srcPixelType == PixelSrcType(style))
+        return;
+
+    srcPixelType = style;
+    shaderProgNeedsChanging = true; //###
+}
+
+void QOpenGLEngineShaderManager::setSrcPixelType(PixelSrcType type)
+{
+    if (srcPixelType == type)
+        return;
+
+    srcPixelType = type;
+    shaderProgNeedsChanging = true; //###
+}
+
+void QOpenGLEngineShaderManager::setOpacityMode(OpacityMode mode)
+{
+    if (opacityMode == mode)
+        return;
+
+    opacityMode = mode;
+    shaderProgNeedsChanging = true; //###
+}
+
+void QOpenGLEngineShaderManager::setMaskType(MaskType type)
+{
+    if (maskType == type)
+        return;
+
+    maskType = type;
+    shaderProgNeedsChanging = true; //###
+}
+
+void QOpenGLEngineShaderManager::setCompositionMode(QPainter::CompositionMode mode)
+{
+    if (compositionMode == mode)
+        return;
+
+    bool wasAdvanced = compositionMode > QPainter::CompositionMode_Plus;
+    bool isAdvanced = mode > QPainter::CompositionMode_Plus;
+
+    compositionMode = mode;
+    shaderProgNeedsChanging = shaderProgNeedsChanging || wasAdvanced || isAdvanced;
+}
+
+void QOpenGLEngineShaderManager::setCustomStage(QOpenGLCustomShaderStage* stage)
+{
+    if (customSrcStage)
+        removeCustomStage();
+    customSrcStage = stage;
+    shaderProgNeedsChanging = true;
+}
+
+void QOpenGLEngineShaderManager::removeCustomStage()
+{
+    if (customSrcStage)
+        customSrcStage->setInactive();
+    customSrcStage = nullptr;
+    shaderProgNeedsChanging = true;
+}
+
+QOpenGLShaderProgram* QOpenGLEngineShaderManager::currentProgram()
+{
+    if (currentShaderProg)
+        return currentShaderProg->program;
+    else
+        return sharedShaders->simpleProgram();
+}
+
+void QOpenGLEngineShaderManager::useSimpleProgram()
+{
+    sharedShaders->simpleProgram()->bind();
+    QOpenGLContextPrivate* ctx_d = ctx->d_func();
+    Q_UNUSED(ctx_d);
+
+    QOpenGL2PaintEngineEx *active_engine = static_cast<QOpenGL2PaintEngineEx *>(ctx_d->active_engine);
+
+    active_engine->d_func()->setVertexAttribArrayEnabled(QT_VERTEX_COORDS_ATTR, true);
+    active_engine->d_func()->setVertexAttribArrayEnabled(QT_TEXTURE_COORDS_ATTR, false);
+    active_engine->d_func()->setVertexAttribArrayEnabled(QT_OPACITY_ATTR, false);
+
+    shaderProgNeedsChanging = true;
+}
+
+void QOpenGLEngineShaderManager::useBlitProgram()
+{
+    sharedShaders->blitProgram()->bind();
+    QOpenGLContextPrivate* ctx_d = ctx->d_func();
+    QOpenGL2PaintEngineEx *active_engine = static_cast<QOpenGL2PaintEngineEx *>(ctx_d->active_engine);
+    active_engine->d_func()->setVertexAttribArrayEnabled(QT_VERTEX_COORDS_ATTR, true);
+    active_engine->d_func()->setVertexAttribArrayEnabled(QT_TEXTURE_COORDS_ATTR, true);
+    active_engine->d_func()->setVertexAttribArrayEnabled(QT_OPACITY_ATTR, false);
+    shaderProgNeedsChanging = true;
+}
+
+QOpenGLShaderProgram* QOpenGLEngineShaderManager::simpleProgram()
+{
+    return sharedShaders->simpleProgram();
+}
+
+QOpenGLShaderProgram* QOpenGLEngineShaderManager::blitProgram()
+{
+    return sharedShaders->blitProgram();
+}
+
+
+
+// Select & use the correct shader program using the current state.
+// Returns \c true if program needed changing.
+bool QOpenGLEngineShaderManager::useCorrectShaderProg()
+{
+    if (!shaderProgNeedsChanging)
+        return false;
+
+    bool useCustomSrc = customSrcStage != nullptr;
+    if (useCustomSrc && srcPixelType != QOpenGLEngineShaderManager::ImageSrc && srcPixelType != Qt::TexturePattern) {
+        useCustomSrc = false;
+        qWarning("QOpenGLEngineShaderManager - Ignoring custom shader stage for non image src");
+    }
+
+    QOpenGLEngineShaderProg requiredProgram;
+
+    bool texCoords = false;
+
+    // Choose vertex shader shader position function (which typically also sets
+    // varyings) and the source pixel (srcPixel) fragment shader function:
+    requiredProgram.positionVertexShader = QOpenGLEngineSharedShaders::InvalidSnippetName;
+    requiredProgram.srcPixelFragShader = QOpenGLEngineSharedShaders::InvalidSnippetName;
+    bool isAffine = brushTransform.isAffine();
+    if ( (srcPixelType >= Qt::Dense1Pattern) && (srcPixelType <= Qt::DiagCrossPattern) ) {
+        if (isAffine)
+            requiredProgram.positionVertexShader = QOpenGLEngineSharedShaders::AffinePositionWithPatternBrushVertexShader;
+        else
+            requiredProgram.positionVertexShader = QOpenGLEngineSharedShaders::PositionWithPatternBrushVertexShader;
+
+        requiredProgram.srcPixelFragShader = QOpenGLEngineSharedShaders::PatternBrushSrcFragmentShader;
+    }
+    else switch (srcPixelType) {
+        default:
+        case Qt::NoBrush:
+            qFatal("QOpenGLEngineShaderManager::useCorrectShaderProg() - Qt::NoBrush style is set");
+            break;
+        case QOpenGLEngineShaderManager::ImageSrc:
+            requiredProgram.srcPixelFragShader = QOpenGLEngineSharedShaders::ImageSrcFragmentShader;
+            requiredProgram.positionVertexShader = QOpenGLEngineSharedShaders::PositionOnlyVertexShader;
+            texCoords = true;
+            break;
+        case QOpenGLEngineShaderManager::NonPremultipliedImageSrc:
+            requiredProgram.srcPixelFragShader = QOpenGLEngineSharedShaders::NonPremultipliedImageSrcFragmentShader;
+            requiredProgram.positionVertexShader = QOpenGLEngineSharedShaders::PositionOnlyVertexShader;
+            texCoords = true;
+            break;
+        case QOpenGLEngineShaderManager::GrayscaleImageSrc:
+            requiredProgram.srcPixelFragShader = QOpenGLEngineSharedShaders::GrayscaleImageSrcFragmentShader;
+            requiredProgram.positionVertexShader = QOpenGLEngineSharedShaders::PositionOnlyVertexShader;
+            texCoords = true;
+            break;
+        case QOpenGLEngineShaderManager::AlphaImageSrc:
+            requiredProgram.srcPixelFragShader = QOpenGLEngineSharedShaders::AlphaImageSrcFragmentShader;
+            requiredProgram.positionVertexShader = QOpenGLEngineSharedShaders::PositionOnlyVertexShader;
+            texCoords = true;
+            break;
+        case QOpenGLEngineShaderManager::PatternSrc:
+            requiredProgram.srcPixelFragShader = QOpenGLEngineSharedShaders::ImageSrcWithPatternFragmentShader;
+            requiredProgram.positionVertexShader = QOpenGLEngineSharedShaders::PositionOnlyVertexShader;
+            texCoords = true;
+            break;
+        case QOpenGLEngineShaderManager::TextureSrcWithPattern:
+            requiredProgram.srcPixelFragShader = QOpenGLEngineSharedShaders::TextureBrushSrcWithPatternFragmentShader;
+            requiredProgram.positionVertexShader = isAffine ? QOpenGLEngineSharedShaders::AffinePositionWithTextureBrushVertexShader
+                                                : QOpenGLEngineSharedShaders::PositionWithTextureBrushVertexShader;
+            break;
+        case Qt::SolidPattern:
+            requiredProgram.srcPixelFragShader = QOpenGLEngineSharedShaders::SolidBrushSrcFragmentShader;
+            requiredProgram.positionVertexShader = QOpenGLEngineSharedShaders::PositionOnlyVertexShader;
+            break;
+        case Qt::LinearGradientPattern:
+            requiredProgram.srcPixelFragShader = QOpenGLEngineSharedShaders::LinearGradientBrushSrcFragmentShader;
+            requiredProgram.positionVertexShader = isAffine ? QOpenGLEngineSharedShaders::AffinePositionWithLinearGradientBrushVertexShader
+                                                : QOpenGLEngineSharedShaders::PositionWithLinearGradientBrushVertexShader;
+            break;
+        case Qt::ConicalGradientPattern:
+            requiredProgram.srcPixelFragShader = QOpenGLEngineSharedShaders::ConicalGradientBrushSrcFragmentShader;
+            requiredProgram.positionVertexShader = isAffine ? QOpenGLEngineSharedShaders::AffinePositionWithConicalGradientBrushVertexShader
+                                                : QOpenGLEngineSharedShaders::PositionWithConicalGradientBrushVertexShader;
+            break;
+        case Qt::RadialGradientPattern:
+            requiredProgram.srcPixelFragShader = QOpenGLEngineSharedShaders::RadialGradientBrushSrcFragmentShader;
+            requiredProgram.positionVertexShader = isAffine ? QOpenGLEngineSharedShaders::AffinePositionWithRadialGradientBrushVertexShader
+                                                : QOpenGLEngineSharedShaders::PositionWithRadialGradientBrushVertexShader;
+            break;
+        case Qt::TexturePattern:
+            requiredProgram.srcPixelFragShader = QOpenGLEngineSharedShaders::TextureBrushSrcFragmentShader;
+            requiredProgram.positionVertexShader = isAffine ? QOpenGLEngineSharedShaders::AffinePositionWithTextureBrushVertexShader
+                                                : QOpenGLEngineSharedShaders::PositionWithTextureBrushVertexShader;
+            break;
+    };
+
+    if (useCustomSrc) {
+        requiredProgram.srcPixelFragShader = QOpenGLEngineSharedShaders::CustomImageSrcFragmentShader;
+        requiredProgram.customStageSource = customSrcStage->source();
+    }
+
+    const bool hasCompose = compositionMode > QPainter::CompositionMode_Plus;
+    const bool hasMask = maskType != QOpenGLEngineShaderManager::NoMask;
+
+    // Choose fragment shader main function:
+    if (opacityMode == AttributeOpacity) {
+        Q_ASSERT(!hasCompose && !hasMask);
+        requiredProgram.mainFragShader = QOpenGLEngineSharedShaders::MainFragmentShader_ImageArrays;
+    } else {
+        bool useGlobalOpacity = (opacityMode == UniformOpacity);
+        if (hasMask && useGlobalOpacity)
+            requiredProgram.mainFragShader = QOpenGLEngineSharedShaders::MainFragmentShader_MO;
+        if (hasMask && !useGlobalOpacity)
+            requiredProgram.mainFragShader = QOpenGLEngineSharedShaders::MainFragmentShader_M;
+        if (!hasMask && useGlobalOpacity)
+            requiredProgram.mainFragShader = QOpenGLEngineSharedShaders::MainFragmentShader_O;
+        if (!hasMask && !useGlobalOpacity)
+            requiredProgram.mainFragShader = QOpenGLEngineSharedShaders::MainFragmentShader;
+    }
+
+    if (hasMask) {
+        if (maskType == PixelMask) {
+            requiredProgram.maskFragShader = QOpenGLEngineSharedShaders::MaskFragmentShader;
+            texCoords = true;
+        } else if (maskType == SubPixelMaskPass1) {
+            requiredProgram.maskFragShader = QOpenGLEngineSharedShaders::RgbMaskFragmentShaderPass1;
+            texCoords = true;
+        } else if (maskType == SubPixelMaskPass2) {
+            requiredProgram.maskFragShader = QOpenGLEngineSharedShaders::RgbMaskFragmentShaderPass2;
+            texCoords = true;
+        } else if (maskType == SubPixelWithGammaMask) {
+            requiredProgram.maskFragShader = QOpenGLEngineSharedShaders::RgbMaskWithGammaFragmentShader;
+            texCoords = true;
+        } else {
+            qCritical("QOpenGLEngineShaderManager::useCorrectShaderProg() - Unknown mask type");
+        }
+    } else {
+        requiredProgram.maskFragShader = QOpenGLEngineSharedShaders::NoMaskFragmentShader;
+    }
+
+    if (hasCompose) {
+        switch (compositionMode) {
+            case QPainter::CompositionMode_Multiply:
+                requiredProgram.compositionFragShader = QOpenGLEngineSharedShaders::MultiplyCompositionModeFragmentShader;
+                break;
+            case QPainter::CompositionMode_Screen:
+                requiredProgram.compositionFragShader = QOpenGLEngineSharedShaders::ScreenCompositionModeFragmentShader;
+                break;
+            case QPainter::CompositionMode_Overlay:
+                requiredProgram.compositionFragShader = QOpenGLEngineSharedShaders::OverlayCompositionModeFragmentShader;
+                break;
+            case QPainter::CompositionMode_Darken:
+                requiredProgram.compositionFragShader = QOpenGLEngineSharedShaders::DarkenCompositionModeFragmentShader;
+                break;
+            case QPainter::CompositionMode_Lighten:
+                requiredProgram.compositionFragShader = QOpenGLEngineSharedShaders::LightenCompositionModeFragmentShader;
+                break;
+            case QPainter::CompositionMode_ColorDodge:
+                requiredProgram.compositionFragShader = QOpenGLEngineSharedShaders::ColorDodgeCompositionModeFragmentShader;
+                break;
+            case QPainter::CompositionMode_ColorBurn:
+                requiredProgram.compositionFragShader = QOpenGLEngineSharedShaders::ColorBurnCompositionModeFragmentShader;
+                break;
+            case QPainter::CompositionMode_HardLight:
+                requiredProgram.compositionFragShader = QOpenGLEngineSharedShaders::HardLightCompositionModeFragmentShader;
+                break;
+            case QPainter::CompositionMode_SoftLight:
+                requiredProgram.compositionFragShader = QOpenGLEngineSharedShaders::SoftLightCompositionModeFragmentShader;
+                break;
+            case QPainter::CompositionMode_Difference:
+                requiredProgram.compositionFragShader = QOpenGLEngineSharedShaders::DifferenceCompositionModeFragmentShader;
+                break;
+            case QPainter::CompositionMode_Exclusion:
+                requiredProgram.compositionFragShader = QOpenGLEngineSharedShaders::ExclusionCompositionModeFragmentShader;
+                break;
+            default:
+                qWarning("QOpenGLEngineShaderManager::useCorrectShaderProg() - Unsupported composition mode");
+        }
+    } else {
+        requiredProgram.compositionFragShader = QOpenGLEngineSharedShaders::NoCompositionModeFragmentShader;
+    }
+
+    // Choose vertex shader main function
+    if (opacityMode == AttributeOpacity) {
+        Q_ASSERT(texCoords);
+        requiredProgram.mainVertexShader = QOpenGLEngineSharedShaders::MainWithTexCoordsAndOpacityVertexShader;
+    } else if (texCoords) {
+        requiredProgram.mainVertexShader = QOpenGLEngineSharedShaders::MainWithTexCoordsVertexShader;
+    } else {
+        requiredProgram.mainVertexShader = QOpenGLEngineSharedShaders::MainVertexShader;
+    }
+    requiredProgram.useTextureCoords = texCoords;
+    requiredProgram.useOpacityAttribute = (opacityMode == AttributeOpacity);
+    if (complexGeometry && srcPixelType == Qt::SolidPattern) {
+        requiredProgram.positionVertexShader = QOpenGLEngineSharedShaders::ComplexGeometryPositionOnlyVertexShader;
+        requiredProgram.usePmvMatrixAttribute = false;
+    } else {
+        requiredProgram.usePmvMatrixAttribute = true;
+
+        // Force complexGeometry off, since we currently don't support that mode for
+        // non-solid brushes
+        complexGeometry = false;
+    }
+
+    // At this point, requiredProgram is fully populated so try to find the program in the cache
+    currentShaderProg = sharedShaders->findProgramInCache(requiredProgram);
+
+    if (currentShaderProg && useCustomSrc) {
+        customSrcStage->setUniforms(currentShaderProg->program);
+    }
+
+    // Make sure all the vertex attribute arrays the program uses are enabled (and the ones it
+    // doesn't use are disabled)
+    QOpenGLContextPrivate* ctx_d = ctx->d_func();
+    QOpenGL2PaintEngineEx *active_engine = static_cast<QOpenGL2PaintEngineEx *>(ctx_d->active_engine);
+    active_engine->d_func()->setVertexAttribArrayEnabled(QT_VERTEX_COORDS_ATTR, true);
+    active_engine->d_func()->setVertexAttribArrayEnabled(QT_TEXTURE_COORDS_ATTR, currentShaderProg && currentShaderProg->useTextureCoords);
+    active_engine->d_func()->setVertexAttribArrayEnabled(QT_OPACITY_ATTR, currentShaderProg && currentShaderProg->useOpacityAttribute);
+
+    shaderProgNeedsChanging = false;
+    return true;
+}
+
+QT_END_NAMESPACE
diff --git a/src/opengl/qopenglengineshadermanager_p.h b/src/opengl/qopenglengineshadermanager_p.h
new file mode 100644
index 0000000000..71e6214278
--- /dev/null
+++ b/src/opengl/qopenglengineshadermanager_p.h
@@ -0,0 +1,506 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtOpenGL module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+/*
+    VERTEX SHADERS
+    ==============
+
+    Vertex shaders are specified as multiple (partial) shaders. On desktop,
+    this works fine. On ES, QOpenGLShader & QOpenGLShaderProgram will make partial
+    shaders work by concatenating the source in each QOpenGLShader and compiling
+    it as a single shader. This is abstracted nicely by QOpenGLShaderProgram and
+    the GL2 engine doesn't need to worry about it.
+
+    Generally, there's two vertex shader objects. The position shaders are
+    the ones which set gl_Position. There's also two "main" vertex shaders,
+    one which just calls the position shader and another which also passes
+    through some texture coordinates from a vertex attribute array to a
+    varying. These texture coordinates are used for mask position in text
+    rendering and for the source coordinates in drawImage/drawPixmap. There's
+    also a "Simple" vertex shader for rendering a solid colour (used to render
+    into the stencil buffer where the actual colour value is discarded).
+
+    The position shaders for brushes look scary. This is because many of the
+    calculations which logically belong in the fragment shader have been moved
+    into the vertex shader to improve performance. This is why the position
+    calculation is in a separate shader. Not only does it calculate the
+    position, but it also calculates some data to be passed to the fragment
+    shader as a varying. It is optimal to move as much of the calculation as
+    possible into the vertex shader as this is executed less often.
+
+    The varyings passed to the fragment shaders are interpolated (which is
+    cheap). Unfortunately, GL will apply perspective correction to the
+    interpolation calusing errors. To get around this, the vertex shader must
+    apply perspective correction itself and set the w-value of gl_Position to
+    zero. That way, GL will be tricked into thinking it doesn't need to apply a
+    perspective correction and use linear interpolation instead (which is what
+    we want). Of course, if the brush transform is affeine, no perspective
+    correction is needed and a simpler vertex shader can be used instead.
+
+    So there are the following "main" vertex shaders:
+        qopenglslMainVertexShader
+        qopenglslMainWithTexCoordsVertexShader
+
+    And the following position vertex shaders:
+        qopenglslPositionOnlyVertexShader
+        qopenglslPositionWithTextureBrushVertexShader
+        qopenglslPositionWithPatternBrushVertexShader
+        qopenglslPositionWithLinearGradientBrushVertexShader
+        qopenglslPositionWithRadialGradientBrushVertexShader
+        qopenglslPositionWithConicalGradientBrushVertexShader
+        qopenglslAffinePositionWithTextureBrushVertexShader
+        qopenglslAffinePositionWithPatternBrushVertexShader
+        qopenglslAffinePositionWithLinearGradientBrushVertexShader
+        qopenglslAffinePositionWithRadialGradientBrushVertexShader
+        qopenglslAffinePositionWithConicalGradientBrushVertexShader
+
+    Leading to 23 possible vertex shaders
+
+
+    FRAGMENT SHADERS
+    ================
+
+    Fragment shaders are also specified as multiple (partial) shaders. The
+    different fragment shaders represent the different stages in Qt's fragment
+    pipeline. There are 1-3 stages in this pipeline: First stage is to get the
+    fragment's colour value. The next stage is to get the fragment's mask value
+    (coverage value for anti-aliasing) and the final stage is to blend the
+    incoming fragment with the background (for composition modes not supported
+    by GL).
+
+    Of these, the first stage will always be present. If Qt doesn't need to
+    apply anti-aliasing (because it's off or handled by multisampling) then
+    the coverage value doesn't need to be applied. (Note: There are two types
+    of mask, one for regular anti-aliasing and one for sub-pixel anti-
+    aliasing.) If the composition mode is one which GL supports natively then
+    the blending stage doesn't need to be applied.
+
+    As eash stage can have multiple implementations, they are abstracted as
+    GLSL function calls with the following signatures:
+
+    Brushes & image drawing are implementations of "qcolorp vec4 srcPixel()":
+        qopenglslImageSrcFragShader
+        qopenglslImageSrcWithPatternFragShader
+        qopenglslNonPremultipliedImageSrcFragShader
+        qopenglslSolidBrushSrcFragShader
+        qopenglslTextureBrushSrcFragShader
+        qopenglslTextureBrushWithPatternFragShader
+        qopenglslPatternBrushSrcFragShader
+        qopenglslLinearGradientBrushSrcFragShader
+        qopenglslRadialGradientBrushSrcFragShader
+        qopenglslConicalGradientBrushSrcFragShader
+    NOTE: It is assumed the colour returned by srcPixel() is pre-multiplied
+
+    Masks are implementations of "qcolorp vec4 applyMask(qcolorp vec4 src)":
+        qopenglslMaskFragmentShader
+        qopenglslRgbMaskFragmentShaderPass1
+        qopenglslRgbMaskFragmentShaderPass2
+        qopenglslRgbMaskWithGammaFragmentShader
+
+    Composition modes are "qcolorp vec4 compose(qcolorp vec4 src)":
+        qopenglslColorBurnCompositionModeFragmentShader
+        qopenglslColorDodgeCompositionModeFragmentShader
+        qopenglslDarkenCompositionModeFragmentShader
+        qopenglslDifferenceCompositionModeFragmentShader
+        qopenglslExclusionCompositionModeFragmentShader
+        qopenglslHardLightCompositionModeFragmentShader
+        qopenglslLightenCompositionModeFragmentShader
+        qopenglslMultiplyCompositionModeFragmentShader
+        qopenglslOverlayCompositionModeFragmentShader
+        qopenglslScreenCompositionModeFragmentShader
+        qopenglslSoftLightCompositionModeFragmentShader
+
+
+    Note: In the future, some GLSL compilers will support an extension allowing
+          a new 'color' precision specifier. To support this, qcolorp is used for
+          all color components so it can be defined to colorp or lowp depending upon
+          the implementation.
+
+    So there are differnt frament shader main functions, depending on the
+    number & type of pipelines the fragment needs to go through.
+
+    The choice of which main() fragment shader string to use depends on:
+        - Use of global opacity
+        - Brush style (some brushes apply opacity themselves)
+        - Use & type of mask (TODO: Need to support high quality anti-aliasing & text)
+        - Use of non-GL Composition mode
+
+    Leading to the following fragment shader main functions:
+        gl_FragColor = compose(applyMask(srcPixel()*globalOpacity));
+        gl_FragColor = compose(applyMask(srcPixel()));
+        gl_FragColor = applyMask(srcPixel()*globalOpacity);
+        gl_FragColor = applyMask(srcPixel());
+        gl_FragColor = compose(srcPixel()*globalOpacity);
+        gl_FragColor = compose(srcPixel());
+        gl_FragColor = srcPixel()*globalOpacity;
+        gl_FragColor = srcPixel();
+
+    Called:
+        qopenglslMainFragmentShader_CMO
+        qopenglslMainFragmentShader_CM
+        qopenglslMainFragmentShader_MO
+        qopenglslMainFragmentShader_M
+        qopenglslMainFragmentShader_CO
+        qopenglslMainFragmentShader_C
+        qopenglslMainFragmentShader_O
+        qopenglslMainFragmentShader
+
+    Where:
+        M = Mask
+        C = Composition
+        O = Global Opacity
+
+
+    CUSTOM SHADER CODE
+    ==================
+
+    The use of custom shader code is supported by the engine for drawImage and
+    drawPixmap calls. This is implemented via hooks in the fragment pipeline.
+
+    The custom shader is passed to the engine as a partial fragment shader
+    (QOpenGLCustomShaderStage). The shader will implement a pre-defined method name
+    which Qt's fragment pipeline will call:
+
+        lowp vec4 customShader(lowp sampler2d imageTexture, highp vec2 textureCoords)
+
+    The provided src and srcCoords parameters can be used to sample from the
+    source image.
+
+    Transformations, clipping, opacity, and composition modes set using QPainter
+    will be respected when using the custom shader hook.
+*/
+
+#ifndef QOPENGLENGINE_SHADER_MANAGER_H
+#define QOPENGLENGINE_SHADER_MANAGER_H
+
+#include <QOpenGLShader>
+#include <QOpenGLShaderProgram>
+#include <QPainter>
+#include <private/qopenglcontext_p.h>
+#include <private/qopenglcustomshaderstage_p.h>
+
+QT_BEGIN_NAMESPACE
+
+
+
+/*
+struct QOpenGLEngineCachedShaderProg
+{
+    QOpenGLEngineCachedShaderProg(QOpenGLEngineShaderManager::ShaderName vertexMain,
+                              QOpenGLEngineShaderManager::ShaderName vertexPosition,
+                              QOpenGLEngineShaderManager::ShaderName fragMain,
+                              QOpenGLEngineShaderManager::ShaderName pixelSrc,
+                              QOpenGLEngineShaderManager::ShaderName mask,
+                              QOpenGLEngineShaderManager::ShaderName composition);
+
+    int cacheKey;
+    QOpenGLShaderProgram* program;
+}
+*/
+
+static const GLuint QT_VERTEX_COORDS_ATTR  = 0;
+static const GLuint QT_TEXTURE_COORDS_ATTR = 1;
+static const GLuint QT_OPACITY_ATTR = 2;
+static const GLuint QT_PMV_MATRIX_1_ATTR = 3;
+static const GLuint QT_PMV_MATRIX_2_ATTR = 4;
+static const GLuint QT_PMV_MATRIX_3_ATTR = 5;
+
+class QOpenGLEngineShaderProg;
+
+class Q_OPENGL_EXPORT QOpenGLEngineSharedShaders
+{
+    Q_GADGET
+public:
+
+    enum SnippetName {
+        MainVertexShader,
+        MainWithTexCoordsVertexShader,
+        MainWithTexCoordsAndOpacityVertexShader,
+
+        // UntransformedPositionVertexShader must be first in the list:
+        UntransformedPositionVertexShader,
+        PositionOnlyVertexShader,
+        ComplexGeometryPositionOnlyVertexShader,
+        PositionWithPatternBrushVertexShader,
+        PositionWithLinearGradientBrushVertexShader,
+        PositionWithConicalGradientBrushVertexShader,
+        PositionWithRadialGradientBrushVertexShader,
+        PositionWithTextureBrushVertexShader,
+        AffinePositionWithPatternBrushVertexShader,
+        AffinePositionWithLinearGradientBrushVertexShader,
+        AffinePositionWithConicalGradientBrushVertexShader,
+        AffinePositionWithRadialGradientBrushVertexShader,
+        AffinePositionWithTextureBrushVertexShader,
+
+        // MainFragmentShader_CMO must be first in the list:
+        MainFragmentShader_MO,
+        MainFragmentShader_M,
+        MainFragmentShader_O,
+        MainFragmentShader,
+        MainFragmentShader_ImageArrays,
+
+        // ImageSrcFragmentShader must be first in the list::
+        ImageSrcFragmentShader,
+        ImageSrcWithPatternFragmentShader,
+        NonPremultipliedImageSrcFragmentShader,
+        GrayscaleImageSrcFragmentShader,
+        AlphaImageSrcFragmentShader,
+        CustomImageSrcFragmentShader,
+        SolidBrushSrcFragmentShader,
+        TextureBrushSrcFragmentShader,
+        TextureBrushSrcWithPatternFragmentShader,
+        PatternBrushSrcFragmentShader,
+        LinearGradientBrushSrcFragmentShader,
+        RadialGradientBrushSrcFragmentShader,
+        ConicalGradientBrushSrcFragmentShader,
+        ShockingPinkSrcFragmentShader,
+
+        // NoMaskFragmentShader must be first in the list:
+        NoMaskFragmentShader,
+        MaskFragmentShader,
+        RgbMaskFragmentShaderPass1,
+        RgbMaskFragmentShaderPass2,
+        RgbMaskWithGammaFragmentShader,
+
+        // NoCompositionModeFragmentShader must be first in the list:
+        NoCompositionModeFragmentShader,
+        MultiplyCompositionModeFragmentShader,
+        ScreenCompositionModeFragmentShader,
+        OverlayCompositionModeFragmentShader,
+        DarkenCompositionModeFragmentShader,
+        LightenCompositionModeFragmentShader,
+        ColorDodgeCompositionModeFragmentShader,
+        ColorBurnCompositionModeFragmentShader,
+        HardLightCompositionModeFragmentShader,
+        SoftLightCompositionModeFragmentShader,
+        DifferenceCompositionModeFragmentShader,
+        ExclusionCompositionModeFragmentShader,
+
+        TotalSnippetCount, InvalidSnippetName
+    };
+#if defined (QT_DEBUG)
+    Q_ENUM(SnippetName)
+    static QByteArray snippetNameStr(SnippetName snippetName);
+#endif
+
+/*
+    // These allow the ShaderName enum to be used as a cache key
+    const int mainVertexOffset = 0;
+    const int positionVertexOffset = (1<<2) - PositionOnlyVertexShader;
+    const int mainFragOffset = (1<<6) - MainFragmentShader_CMO;
+    const int srcPixelOffset = (1<<10) - ImageSrcFragmentShader;
+    const int maskOffset = (1<<14) - NoMaskShader;
+    const int compositionOffset = (1 << 16) - MultiplyCompositionModeFragmentShader;
+*/
+
+    QOpenGLEngineSharedShaders(QOpenGLContext *context);
+    ~QOpenGLEngineSharedShaders();
+
+    QOpenGLShaderProgram *simpleProgram() { return simpleShaderProg; }
+    QOpenGLShaderProgram *blitProgram() { return blitShaderProg; }
+    // Compile the program if it's not already in the cache, return the item in the cache.
+    QOpenGLEngineShaderProg *findProgramInCache(const QOpenGLEngineShaderProg &prog);
+    // Compile the custom shader if it's not already in the cache, return the item in the cache.
+
+    static QOpenGLEngineSharedShaders *shadersForContext(QOpenGLContext *context);
+
+    // Ideally, this would be static and cleanup all programs in all contexts which
+    // contain the custom code. Currently it is just a hint and we rely on deleted
+    // custom shaders being cleaned up by being kicked out of the cache when it's
+    // full.
+    void cleanupCustomStage(QOpenGLCustomShaderStage* stage);
+
+private:
+    QOpenGLShaderProgram *blitShaderProg;
+    QOpenGLShaderProgram *simpleShaderProg;
+    QList<QOpenGLEngineShaderProg*> cachedPrograms;
+
+    static const char* qShaderSnippets[TotalSnippetCount];
+};
+
+
+class QOpenGLEngineShaderProg
+{
+public:
+    QOpenGLEngineShaderProg() : program(nullptr) {}
+
+    ~QOpenGLEngineShaderProg() {
+        if (program)
+            delete program;
+    }
+
+    QOpenGLEngineSharedShaders::SnippetName mainVertexShader;
+    QOpenGLEngineSharedShaders::SnippetName positionVertexShader;
+    QOpenGLEngineSharedShaders::SnippetName mainFragShader;
+    QOpenGLEngineSharedShaders::SnippetName srcPixelFragShader;
+    QOpenGLEngineSharedShaders::SnippetName maskFragShader;
+    QOpenGLEngineSharedShaders::SnippetName compositionFragShader;
+
+    QByteArray          customStageSource; //TODO: Decent cache key for custom stages
+    QOpenGLShaderProgram*   program;
+
+    QVector<uint> uniformLocations;
+
+    bool                useTextureCoords;
+    bool                useOpacityAttribute;
+    bool                usePmvMatrixAttribute;
+
+    bool operator==(const QOpenGLEngineShaderProg& other) const {
+        // We don't care about the program
+        return ( mainVertexShader      == other.mainVertexShader &&
+                 positionVertexShader  == other.positionVertexShader &&
+                 mainFragShader        == other.mainFragShader &&
+                 srcPixelFragShader    == other.srcPixelFragShader &&
+                 maskFragShader        == other.maskFragShader &&
+                 compositionFragShader == other.compositionFragShader &&
+                 customStageSource     == other.customStageSource
+               );
+    }
+};
+
+class Q_OPENGL_EXPORT QOpenGLEngineShaderManager : public QObject
+{
+    Q_OBJECT
+public:
+    QOpenGLEngineShaderManager(QOpenGLContext* context);
+    ~QOpenGLEngineShaderManager();
+
+    enum MaskType {NoMask, PixelMask, SubPixelMaskPass1, SubPixelMaskPass2, SubPixelWithGammaMask};
+    enum PixelSrcType {
+        ImageSrc = Qt::TexturePattern+1,
+        NonPremultipliedImageSrc = Qt::TexturePattern+2,
+        PatternSrc = Qt::TexturePattern+3,
+        TextureSrcWithPattern = Qt::TexturePattern+4,
+        GrayscaleImageSrc = Qt::TexturePattern+5,
+        AlphaImageSrc = Qt::TexturePattern+6,
+    };
+
+    enum Uniform {
+        ImageTexture,
+        PatternColor,
+        GlobalOpacity,
+        Depth,
+        MaskTexture,
+        FragmentColor,
+        LinearData,
+        Angle,
+        HalfViewportSize,
+        Fmp,
+        Fmp2MRadius2,
+        Inverse2Fmp2MRadius2,
+        SqrFr,
+        BRadius,
+        InvertedTextureSize,
+        BrushTransform,
+        BrushTexture,
+        Matrix,
+        NumUniforms
+    };
+
+    enum OpacityMode {
+        NoOpacity,
+        UniformOpacity,
+        AttributeOpacity
+    };
+
+    // There are optimizations we can do, depending on the brush transform:
+    //    1) May not have to apply perspective-correction
+    //    2) Can use lower precision for matrix
+    void optimiseForBrushTransform(QTransform::TransformationType transformType);
+    void setSrcPixelType(Qt::BrushStyle);
+    void setSrcPixelType(PixelSrcType); // For non-brush sources, like pixmaps & images
+    void setOpacityMode(OpacityMode);
+    void setMaskType(MaskType);
+    void setCompositionMode(QPainter::CompositionMode);
+    void setCustomStage(QOpenGLCustomShaderStage* stage);
+    void removeCustomStage();
+
+    GLuint getUniformLocation(Uniform id);
+
+    void setDirty(); // someone has manually changed the current shader program
+    bool useCorrectShaderProg(); // returns true if the shader program needed to be changed
+
+    void useSimpleProgram();
+    void useBlitProgram();
+    void setHasComplexGeometry(bool hasComplexGeometry)
+    {
+        complexGeometry = hasComplexGeometry;
+        shaderProgNeedsChanging = true;
+    }
+    bool hasComplexGeometry() const
+    {
+        return complexGeometry;
+    }
+
+    QOpenGLShaderProgram* currentProgram(); // Returns pointer to the shader the manager has chosen
+    QOpenGLShaderProgram* simpleProgram(); // Used to draw into e.g. stencil buffers
+    QOpenGLShaderProgram* blitProgram(); // Used to blit a texture into the framebuffer
+
+    QOpenGLEngineSharedShaders* sharedShaders;
+
+private:
+    QOpenGLContext*     ctx;
+    bool            shaderProgNeedsChanging;
+    bool            complexGeometry;
+
+    // Current state variables which influence the choice of shader:
+    QTransform                  brushTransform;
+    int                         srcPixelType;
+    OpacityMode                 opacityMode;
+    MaskType                    maskType;
+    QPainter::CompositionMode   compositionMode;
+    QOpenGLCustomShaderStage*       customSrcStage;
+
+    QOpenGLEngineShaderProg*    currentShaderProg;
+};
+
+QT_END_NAMESPACE
+
+#endif //QOPENGLENGINE_SHADER_MANAGER_H
diff --git a/src/opengl/qopenglengineshadersource_p.h b/src/opengl/qopenglengineshadersource_p.h
new file mode 100644
index 0000000000..49d17c8d79
--- /dev/null
+++ b/src/opengl/qopenglengineshadersource_p.h
@@ -0,0 +1,969 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtOpenGL module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+
+#ifndef QOPENGL_ENGINE_SHADER_SOURCE_H
+#define QOPENGL_ENGINE_SHADER_SOURCE_H
+
+#include "qopenglengineshadermanager_p.h"
+
+QT_BEGIN_NAMESPACE
+
+
+static const char* const qopenglslMainVertexShader = "\n\
+    void setPosition(); \n\
+    void main(void) \n\
+    { \n\
+        setPosition(); \n\
+    }\n";
+
+static const char* const qopenglslMainWithTexCoordsVertexShader = "\n\
+    attribute highp   vec2      textureCoordArray; \n\
+    varying   highp   vec2      textureCoords; \n\
+    void setPosition(); \n\
+    void main(void) \n\
+    { \n\
+        setPosition(); \n\
+        textureCoords = textureCoordArray; \n\
+    }\n";
+
+static const char* const qopenglslMainWithTexCoordsAndOpacityVertexShader = "\n\
+    attribute highp   vec2      textureCoordArray; \n\
+    attribute lowp    float     opacityArray; \n\
+    varying   highp   vec2      textureCoords; \n\
+    varying   lowp    float     opacity; \n\
+    void setPosition(); \n\
+    void main(void) \n\
+    { \n\
+        setPosition(); \n\
+        textureCoords = textureCoordArray; \n\
+        opacity = opacityArray; \n\
+    }\n";
+
+// NOTE: We let GL do the perspective correction so texture lookups in the fragment
+//       shader are also perspective corrected.
+static const char* const qopenglslPositionOnlyVertexShader = "\n\
+    attribute highp   vec2      vertexCoordsArray; \n\
+    attribute highp   vec3      pmvMatrix1; \n\
+    attribute highp   vec3      pmvMatrix2; \n\
+    attribute highp   vec3      pmvMatrix3; \n\
+    void setPosition(void) \n\
+    { \n\
+        highp mat3 pmvMatrix = mat3(pmvMatrix1, pmvMatrix2, pmvMatrix3); \n\
+        vec3 transformedPos = pmvMatrix * vec3(vertexCoordsArray.xy, 1.0); \n\
+        gl_Position = vec4(transformedPos.xy, 0.0, transformedPos.z); \n\
+    }\n";
+
+static const char* const qopenglslComplexGeometryPositionOnlyVertexShader = "\n\
+    uniform highp mat3 matrix; \n\
+    attribute highp vec2 vertexCoordsArray; \n\
+    void setPosition(void) \n\
+    { \n\
+      gl_Position = vec4(matrix * vec3(vertexCoordsArray, 1), 1);\n\
+    } \n";
+
+static const char* const qopenglslUntransformedPositionVertexShader = "\n\
+    attribute highp   vec4      vertexCoordsArray; \n\
+    void setPosition(void) \n\
+    { \n\
+        gl_Position = vertexCoordsArray; \n\
+    }\n";
+
+// Pattern Brush - This assumes the texture size is 8x8 and thus, the inverted size is 0.125
+static const char* const qopenglslPositionWithPatternBrushVertexShader = "\n\
+    attribute highp   vec2      vertexCoordsArray; \n\
+    attribute highp   vec3      pmvMatrix1; \n\
+    attribute highp   vec3      pmvMatrix2; \n\
+    attribute highp   vec3      pmvMatrix3; \n\
+    uniform   mediump vec2      halfViewportSize; \n\
+    uniform   highp   vec2      invertedTextureSize; \n\
+    uniform   highp   mat3      brushTransform; \n\
+    varying   highp   vec2      patternTexCoords; \n\
+    void setPosition(void) \n\
+    { \n\
+        highp mat3 pmvMatrix = mat3(pmvMatrix1, pmvMatrix2, pmvMatrix3); \n\
+        vec3 transformedPos = pmvMatrix * vec3(vertexCoordsArray.xy, 1.0); \n\
+        gl_Position.xy = transformedPos.xy / transformedPos.z; \n\
+        mediump vec2 viewportCoords = (gl_Position.xy + 1.0) * halfViewportSize; \n\
+        mediump vec3 hTexCoords = brushTransform * vec3(viewportCoords, 1.0); \n\
+        mediump float invertedHTexCoordsZ = 1.0 / hTexCoords.z; \n\
+        gl_Position = vec4(gl_Position.xy * invertedHTexCoordsZ, 0.0, invertedHTexCoordsZ); \n\
+        patternTexCoords.xy = (hTexCoords.xy * 0.125) * invertedHTexCoordsZ; \n\
+    }\n";
+
+static const char* const qopenglslAffinePositionWithPatternBrushVertexShader
+                 = qopenglslPositionWithPatternBrushVertexShader;
+
+static const char* const qopenglslPatternBrushSrcFragmentShader = "\n\
+    uniform           sampler2D brushTexture; \n\
+    uniform   lowp    vec4      patternColor; \n\
+    varying   highp   vec2      patternTexCoords;\n\
+    lowp vec4 srcPixel() \n\
+    { \n\
+        return patternColor * (1.0 - texture2D(brushTexture, patternTexCoords).r); \n\
+    }\n";
+
+
+// Linear Gradient Brush
+static const char* const qopenglslPositionWithLinearGradientBrushVertexShader = "\n\
+    attribute highp   vec2      vertexCoordsArray; \n\
+    attribute highp   vec3      pmvMatrix1; \n\
+    attribute highp   vec3      pmvMatrix2; \n\
+    attribute highp   vec3      pmvMatrix3; \n\
+    uniform   mediump vec2      halfViewportSize; \n\
+    uniform   highp   vec3      linearData; \n\
+    uniform   highp   mat3      brushTransform; \n\
+    varying   mediump float     index; \n\
+    void setPosition() \n\
+    { \n\
+        highp mat3 pmvMatrix = mat3(pmvMatrix1, pmvMatrix2, pmvMatrix3); \n\
+        vec3 transformedPos = pmvMatrix * vec3(vertexCoordsArray.xy, 1.0); \n\
+        gl_Position.xy = transformedPos.xy / transformedPos.z; \n\
+        mediump vec2 viewportCoords = (gl_Position.xy + 1.0) * halfViewportSize; \n\
+        mediump vec3 hTexCoords = brushTransform * vec3(viewportCoords, 1); \n\
+        mediump float invertedHTexCoordsZ = 1.0 / hTexCoords.z; \n\
+        gl_Position = vec4(gl_Position.xy * invertedHTexCoordsZ, 0.0, invertedHTexCoordsZ); \n\
+        index = (dot(linearData.xy, hTexCoords.xy) * linearData.z) * invertedHTexCoordsZ; \n\
+    }\n";
+
+static const char* const qopenglslAffinePositionWithLinearGradientBrushVertexShader
+                 = qopenglslPositionWithLinearGradientBrushVertexShader;
+
+static const char* const qopenglslLinearGradientBrushSrcFragmentShader = "\n\
+    uniform           sampler2D brushTexture; \n\
+    varying   mediump float     index; \n\
+    lowp vec4 srcPixel() \n\
+    { \n\
+        mediump vec2 val = vec2(index, 0.5); \n\
+        return texture2D(brushTexture, val); \n\
+    }\n";
+
+
+// Conical Gradient Brush
+static const char* const qopenglslPositionWithConicalGradientBrushVertexShader = "\n\
+    attribute highp   vec2      vertexCoordsArray; \n\
+    attribute highp   vec3      pmvMatrix1; \n\
+    attribute highp   vec3      pmvMatrix2; \n\
+    attribute highp   vec3      pmvMatrix3; \n\
+    uniform   mediump vec2      halfViewportSize; \n\
+    uniform   highp   mat3      brushTransform; \n\
+    varying   highp   vec2      A; \n\
+    void setPosition(void) \n\
+    { \n\
+        highp mat3 pmvMatrix = mat3(pmvMatrix1, pmvMatrix2, pmvMatrix3); \n\
+        vec3 transformedPos = pmvMatrix * vec3(vertexCoordsArray.xy, 1.0); \n\
+        gl_Position.xy = transformedPos.xy / transformedPos.z; \n\
+        mediump vec2  viewportCoords = (gl_Position.xy + 1.0) * halfViewportSize; \n\
+        mediump vec3 hTexCoords = brushTransform * vec3(viewportCoords, 1); \n\
+        mediump float invertedHTexCoordsZ = 1.0 / hTexCoords.z; \n\
+        gl_Position = vec4(gl_Position.xy * invertedHTexCoordsZ, 0.0, invertedHTexCoordsZ); \n\
+        A = hTexCoords.xy * invertedHTexCoordsZ; \n\
+    }\n";
+
+static const char* const qopenglslAffinePositionWithConicalGradientBrushVertexShader
+                 = qopenglslPositionWithConicalGradientBrushVertexShader;
+
+static const char* const qopenglslConicalGradientBrushSrcFragmentShader = "\n\
+    #define INVERSE_2PI 0.1591549430918953358 \n\
+    uniform           sampler2D brushTexture; \n\
+    uniform   mediump float     angle; \n\
+    varying   highp   vec2      A; \n\
+    lowp vec4 srcPixel() \n\
+    { \n\
+        highp float t; \n\
+        if (abs(A.y) == abs(A.x)) \n\
+            t = (atan(-A.y + 0.002, A.x) + angle) * INVERSE_2PI; \n\
+        else \n\
+            t = (atan(-A.y, A.x) + angle) * INVERSE_2PI; \n\
+        return texture2D(brushTexture, vec2(t - floor(t), 0.5)); \n\
+    }\n";
+
+
+// Radial Gradient Brush
+static const char* const qopenglslPositionWithRadialGradientBrushVertexShader = "\n\
+    attribute highp   vec2      vertexCoordsArray;\n\
+    attribute highp   vec3      pmvMatrix1; \n\
+    attribute highp   vec3      pmvMatrix2; \n\
+    attribute highp   vec3      pmvMatrix3; \n\
+    uniform   mediump vec2      halfViewportSize; \n\
+    uniform   highp   mat3      brushTransform; \n\
+    uniform   highp   vec2      fmp; \n\
+    uniform   mediump vec3      bradius; \n\
+    varying   highp   float     b; \n\
+    varying   highp   vec2      A; \n\
+    void setPosition(void) \n\
+    {\n\
+        highp mat3 pmvMatrix = mat3(pmvMatrix1, pmvMatrix2, pmvMatrix3); \n\
+        vec3 transformedPos = pmvMatrix * vec3(vertexCoordsArray.xy, 1.0); \n\
+        gl_Position.xy = transformedPos.xy / transformedPos.z; \n\
+        mediump vec2 viewportCoords = (gl_Position.xy + 1.0) * halfViewportSize; \n\
+        mediump vec3 hTexCoords = brushTransform * vec3(viewportCoords, 1); \n\
+        mediump float invertedHTexCoordsZ = 1.0 / hTexCoords.z; \n\
+        gl_Position = vec4(gl_Position.xy * invertedHTexCoordsZ, 0.0, invertedHTexCoordsZ); \n\
+        A = hTexCoords.xy * invertedHTexCoordsZ; \n\
+        b = bradius.x + 2.0 * dot(A, fmp); \n\
+    }\n";
+
+static const char* const qopenglslAffinePositionWithRadialGradientBrushVertexShader
+                 = qopenglslPositionWithRadialGradientBrushVertexShader;
+
+static const char* const qopenglslRadialGradientBrushSrcFragmentShader = "\n\
+    uniform           sampler2D brushTexture; \n\
+    uniform   highp   float     fmp2_m_radius2; \n\
+    uniform   highp   float     inverse_2_fmp2_m_radius2; \n\
+    uniform   highp   float     sqrfr; \n\
+    varying   highp   float     b; \n\
+    varying   highp   vec2      A; \n\
+    uniform   mediump vec3      bradius; \n\
+    lowp vec4 srcPixel() \n\
+    { \n\
+        highp float c = sqrfr-dot(A, A); \n\
+        highp float det = b*b - 4.0*fmp2_m_radius2*c; \n\
+        lowp vec4 result = vec4(0.0); \n\
+        if (det >= 0.0) { \n\
+            highp float detSqrt = sqrt(det); \n\
+            highp float w = max((-b - detSqrt) * inverse_2_fmp2_m_radius2, (-b + detSqrt) * inverse_2_fmp2_m_radius2); \n\
+            if (bradius.y + w * bradius.z >= 0.0) \n\
+                result = texture2D(brushTexture, vec2(w, 0.5)); \n\
+        } \n\
+        return result; \n\
+    }\n";
+
+
+// Texture Brush
+static const char* const qopenglslPositionWithTextureBrushVertexShader = "\n\
+    attribute highp   vec2      vertexCoordsArray; \n\
+    attribute highp   vec3      pmvMatrix1; \n\
+    attribute highp   vec3      pmvMatrix2; \n\
+    attribute highp   vec3      pmvMatrix3; \n\
+    uniform   mediump vec2      halfViewportSize; \n\
+    uniform   highp   vec2      invertedTextureSize; \n\
+    uniform   highp   mat3      brushTransform; \n\
+    varying   highp   vec2      brushTextureCoords; \n\
+    void setPosition(void) \n\
+    { \n\
+        highp mat3 pmvMatrix = mat3(pmvMatrix1, pmvMatrix2, pmvMatrix3); \n\
+        vec3 transformedPos = pmvMatrix * vec3(vertexCoordsArray.xy, 1.0); \n\
+        gl_Position.xy = transformedPos.xy / transformedPos.z; \n\
+        mediump vec2 viewportCoords = (gl_Position.xy + 1.0) * halfViewportSize; \n\
+        mediump vec3 hTexCoords = brushTransform * vec3(viewportCoords, 1); \n\
+        mediump float invertedHTexCoordsZ = 1.0 / hTexCoords.z; \n\
+        gl_Position = vec4(gl_Position.xy * invertedHTexCoordsZ, 0.0, invertedHTexCoordsZ); \n\
+        brushTextureCoords.xy = (hTexCoords.xy * invertedTextureSize) * gl_Position.w; \n\
+    }\n";
+
+static const char* const qopenglslAffinePositionWithTextureBrushVertexShader
+                 = qopenglslPositionWithTextureBrushVertexShader;
+
+static const char* const qopenglslTextureBrushSrcFragmentShader = "\n\
+    varying   highp   vec2      brushTextureCoords; \n\
+    uniform           sampler2D brushTexture; \n\
+    lowp vec4 srcPixel() \n\
+    { \n\
+        return texture2D(brushTexture, brushTextureCoords); \n\
+    }\n";
+
+static const char* const qopenglslTextureBrushSrcWithPatternFragmentShader = "\n\
+    varying   highp   vec2      brushTextureCoords; \n\
+    uniform   lowp    vec4      patternColor; \n\
+    uniform           sampler2D brushTexture; \n\
+    lowp vec4 srcPixel() \n\
+    { \n\
+        return patternColor * (1.0 - texture2D(brushTexture, brushTextureCoords).r); \n\
+    }\n";
+
+// Solid Fill Brush
+static const char* const qopenglslSolidBrushSrcFragmentShader = "\n\
+    uniform   lowp    vec4      fragmentColor; \n\
+    lowp vec4 srcPixel() \n\
+    { \n\
+        return fragmentColor; \n\
+    }\n";
+
+static const char* const qopenglslImageSrcFragmentShader = "\n\
+    varying   highp   vec2      textureCoords; \n\
+    uniform           sampler2D imageTexture; \n\
+    lowp vec4 srcPixel() \n\
+    { \n"
+        "return texture2D(imageTexture, textureCoords); \n"
+    "}\n";
+
+static const char* const qopenglslCustomSrcFragmentShader = "\n\
+    varying   highp   vec2      textureCoords; \n\
+    uniform           sampler2D imageTexture; \n\
+    lowp vec4 srcPixel() \n\
+    { \n\
+        return customShader(imageTexture, textureCoords); \n\
+    }\n";
+
+static const char* const qopenglslImageSrcWithPatternFragmentShader = "\n\
+    varying   highp   vec2      textureCoords; \n\
+    uniform   lowp    vec4      patternColor; \n\
+    uniform           sampler2D imageTexture; \n\
+    lowp vec4 srcPixel() \n\
+    { \n\
+        return patternColor * (1.0 - texture2D(imageTexture, textureCoords).r); \n\
+    }\n";
+
+static const char* const qopenglslNonPremultipliedImageSrcFragmentShader = "\n\
+    varying   highp   vec2      textureCoords; \n\
+    uniform          sampler2D imageTexture; \n\
+    lowp vec4 srcPixel() \n\
+    { \n\
+        lowp vec4 sample = texture2D(imageTexture, textureCoords); \n\
+        sample.rgb = sample.rgb * sample.a; \n\
+        return sample; \n\
+    }\n";
+
+static const char* const qopenglslGrayscaleImageSrcFragmentShader = "\n\
+    varying   highp   vec2      textureCoords; \n\
+    uniform          sampler2D imageTexture; \n\
+    lowp vec4 srcPixel() \n\
+    { \n\
+        return texture2D(imageTexture, textureCoords).rrra; \n\
+    }\n";
+
+static const char* const qopenglslAlphaImageSrcFragmentShader = "\n\
+    varying   highp   vec2      textureCoords; \n\
+    uniform          sampler2D imageTexture; \n\
+    lowp vec4 srcPixel() \n\
+    { \n\
+        return vec4(0, 0, 0, texture2D(imageTexture, textureCoords).r); \n\
+    }\n";
+
+static const char* const qopenglslShockingPinkSrcFragmentShader = "\n\
+    lowp vec4 srcPixel() \n\
+    { \n\
+        return vec4(0.98, 0.06, 0.75, 1.0); \n\
+    }\n";
+
+static const char* const qopenglslMainFragmentShader_ImageArrays = "\n\
+    varying   lowp    float     opacity; \n\
+    lowp vec4 srcPixel(); \n\
+    void main() \n\
+    { \n\
+        gl_FragColor = srcPixel() * opacity; \n\
+    }\n";
+
+static const char* const qopenglslMainFragmentShader_MO = "\n\
+    uniform   lowp    float     globalOpacity; \n\
+    lowp vec4 srcPixel(); \n\
+    lowp vec4 applyMask(lowp vec4); \n\
+    void main() \n\
+    { \n\
+        gl_FragColor = applyMask(srcPixel()*globalOpacity); \n\
+    }\n";
+
+static const char* const qopenglslMainFragmentShader_M = "\n\
+    lowp vec4 srcPixel(); \n\
+    lowp vec4 applyMask(lowp vec4); \n\
+    void main() \n\
+    { \n\
+        gl_FragColor = applyMask(srcPixel()); \n\
+    }\n";
+
+static const char* const qopenglslMainFragmentShader_O = "\n\
+    uniform   lowp    float     globalOpacity; \n\
+    lowp vec4 srcPixel(); \n\
+    void main() \n\
+    { \n\
+        gl_FragColor = srcPixel()*globalOpacity; \n\
+    }\n";
+
+static const char* const qopenglslMainFragmentShader = "\n\
+    lowp vec4 srcPixel(); \n\
+    void main() \n\
+    { \n\
+        gl_FragColor = srcPixel(); \n\
+    }\n";
+
+static const char* const qopenglslMaskFragmentShader = "\n\
+    varying   highp   vec2      textureCoords;\n\
+    uniform           sampler2D maskTexture;\n\
+    lowp vec4 applyMask(lowp vec4 src) \n\
+    {\n\
+        lowp vec4 mask = texture2D(maskTexture, textureCoords); \n\
+        return src * mask.a; \n\
+    }\n";
+
+// For source over with subpixel antialiasing, the final color is calculated per component as follows
+// (.a is alpha component, .c is red, green or blue component):
+// alpha = src.a * mask.c * opacity
+// dest.c = dest.c * (1 - alpha) + src.c * alpha
+//
+// In the first pass, calculate: dest.c = dest.c * (1 - alpha) with blend funcs: zero, 1 - source color
+// In the second pass, calculate: dest.c = dest.c + src.c * alpha with blend funcs: one, one
+//
+// If source is a solid color (src is constant), only the first pass is needed, with blend funcs: constant, 1 - source color
+
+// For source composition with subpixel antialiasing, the final color is calculated per component as follows:
+// alpha = src.a * mask.c * opacity
+// dest.c = dest.c * (1 - mask.c) + src.c * alpha
+//
+
+static const char* const qopenglslRgbMaskFragmentShaderPass1 = "\n\
+    varying   highp   vec2      textureCoords;\n\
+    uniform           sampler2D maskTexture;\n\
+    lowp vec4 applyMask(lowp vec4 src) \n\
+    { \n\
+        lowp vec4 mask = texture2D(maskTexture, textureCoords); \n\
+        return src.a * mask; \n\
+    }\n";
+
+static const char* const qopenglslRgbMaskFragmentShaderPass2 = "\n\
+    varying   highp   vec2      textureCoords;\n\
+    uniform           sampler2D maskTexture;\n\
+    lowp vec4 applyMask(lowp vec4 src) \n\
+    { \n\
+        lowp vec4 mask = texture2D(maskTexture, textureCoords); \n\
+        return src * mask; \n\
+    }\n";
+
+static const char* const qopenglslMultiplyCompositionModeFragmentShader = "\n\
+    #ifdef GL_KHR_blend_equation_advanced\n\
+    layout(blend_support_multiply) out;\n\
+    #endif\n";
+
+static const char* const qopenglslScreenCompositionModeFragmentShader = "\n\
+    #ifdef GL_KHR_blend_equation_advanced\n\
+    layout(blend_support_screen) out;\n\
+    #endif\n";
+
+static const char* const qopenglslOverlayCompositionModeFragmentShader = "\n\
+    #ifdef GL_KHR_blend_equation_advanced\n\
+    layout(blend_support_overlay) out;\n\
+    #endif\n";
+
+static const char* const qopenglslDarkenCompositionModeFragmentShader = "\n\
+    #ifdef GL_KHR_blend_equation_advanced\n\
+    layout(blend_support_darken) out;\n\
+    #endif\n";
+
+static const char* const qopenglslLightenCompositionModeFragmentShader = "\n\
+    #ifdef GL_KHR_blend_equation_advanced\n\
+    layout(blend_support_lighten) out;\n\
+    #endif\n";
+
+static const char* const qopenglslColorDodgeCompositionModeFragmentShader = "\n\
+    #ifdef GL_KHR_blend_equation_advanced\n\
+    layout(blend_support_colordodge) out;\n\
+    #endif\n";
+
+static const char* const qopenglslColorBurnCompositionModeFragmentShader = "\n\
+    #ifdef GL_KHR_blend_equation_advanced\n\
+    layout(blend_support_colorburn) out;\n\
+    #endif\n";
+
+static const char* const qopenglslHardLightCompositionModeFragmentShader = "\n\
+    #ifdef GL_KHR_blend_equation_advanced\n\
+    layout(blend_support_hardlight) out;\n\
+    #endif\n";
+
+static const char* const qopenglslSoftLightCompositionModeFragmentShader = "\n\
+    #ifdef GL_KHR_blend_equation_advanced\n\
+    layout(blend_support_softlight) out;\n\
+    #endif\n";
+
+static const char* const qopenglslDifferenceCompositionModeFragmentShader = "\n\
+    #ifdef GL_KHR_blend_equation_advanced\n\
+    layout(blend_support_difference) out;\n\
+    #endif\n";
+
+static const char* const qopenglslExclusionCompositionModeFragmentShader = "\n\
+    #ifdef GL_KHR_blend_equation_advanced\n\
+    layout(blend_support_exclusion) out;\n\
+    #endif\n";
+
+/*
+    Left to implement:
+        RgbMaskFragmentShader,
+        RgbMaskWithGammaFragmentShader,
+*/
+
+/*
+    OpenGL 3.2+ Core Profile shaders
+    The following shader snippets are copies of the snippets above
+    but use the modern GLSL 1.5 keywords. New shaders should make
+    a snippet for both profiles and add them appropriately in the
+    shader manager.
+*/
+static const char* const qopenglslMainVertexShader_core =
+    "#version 150 core\n\
+    void setPosition(); \n\
+    void main(void) \n\
+    { \n\
+        setPosition(); \n\
+    }\n";
+
+static const char* const qopenglslMainWithTexCoordsVertexShader_core =
+    "#version 150 core\n\
+    in      vec2      textureCoordArray; \n\
+    out     vec2      textureCoords; \n\
+    void setPosition(); \n\
+    void main(void) \n\
+    { \n\
+        setPosition(); \n\
+        textureCoords = textureCoordArray; \n\
+    }\n";
+
+static const char* const qopenglslMainWithTexCoordsAndOpacityVertexShader_core =
+    "#version 150 core\n\
+    in      vec2      textureCoordArray; \n\
+    in      float     opacityArray; \n\
+    out     vec2      textureCoords; \n\
+    out     float     opacity; \n\
+    void setPosition(); \n\
+    void main(void) \n\
+    { \n\
+        setPosition(); \n\
+        textureCoords = textureCoordArray; \n\
+        opacity = opacityArray; \n\
+    }\n";
+
+// NOTE: We let GL do the perspective correction so texture lookups in the fragment
+//       shader are also perspective corrected.
+static const char* const qopenglslPositionOnlyVertexShader_core = "\n\
+    in      vec2      vertexCoordsArray; \n\
+    in      vec3      pmvMatrix1; \n\
+    in      vec3      pmvMatrix2; \n\
+    in      vec3      pmvMatrix3; \n\
+    void setPosition(void) \n\
+    { \n\
+        mat3 pmvMatrix = mat3(pmvMatrix1, pmvMatrix2, pmvMatrix3); \n\
+        vec3 transformedPos = pmvMatrix * vec3(vertexCoordsArray.xy, 1.0); \n\
+        gl_Position = vec4(transformedPos.xy, 0.0, transformedPos.z); \n\
+    }\n";
+
+static const char* const qopenglslComplexGeometryPositionOnlyVertexShader_core = "\n\
+    in      vec2      vertexCoordsArray; \n\
+    uniform mat3      matrix; \n\
+    void setPosition(void) \n\
+    { \n\
+      gl_Position = vec4(matrix * vec3(vertexCoordsArray, 1), 1);\n\
+    } \n";
+
+static const char* const qopenglslUntransformedPositionVertexShader_core = "\n\
+    in      vec4      vertexCoordsArray; \n\
+    void setPosition(void) \n\
+    { \n\
+        gl_Position = vertexCoordsArray; \n\
+    }\n";
+
+// Pattern Brush - This assumes the texture size is 8x8 and thus, the inverted size is 0.125
+static const char* const qopenglslPositionWithPatternBrushVertexShader_core = "\n\
+    in      vec2      vertexCoordsArray; \n\
+    in      vec3      pmvMatrix1; \n\
+    in      vec3      pmvMatrix2; \n\
+    in      vec3      pmvMatrix3; \n\
+    out     vec2      patternTexCoords; \n\
+    uniform vec2      halfViewportSize; \n\
+    uniform vec2      invertedTextureSize; \n\
+    uniform mat3      brushTransform; \n\
+    void setPosition(void) \n\
+    { \n\
+        mat3 pmvMatrix = mat3(pmvMatrix1, pmvMatrix2, pmvMatrix3); \n\
+        vec3 transformedPos = pmvMatrix * vec3(vertexCoordsArray.xy, 1.0); \n\
+        gl_Position.xy = transformedPos.xy / transformedPos.z; \n\
+        vec2 viewportCoords = (gl_Position.xy + 1.0) * halfViewportSize; \n\
+        vec3 hTexCoords = brushTransform * vec3(viewportCoords, 1.0); \n\
+        float invertedHTexCoordsZ = 1.0 / hTexCoords.z; \n\
+        gl_Position = vec4(gl_Position.xy * invertedHTexCoordsZ, 0.0, invertedHTexCoordsZ); \n\
+        patternTexCoords.xy = (hTexCoords.xy * 0.125) * invertedHTexCoordsZ; \n\
+    }\n";
+
+static const char* const qopenglslAffinePositionWithPatternBrushVertexShader_core
+                 = qopenglslPositionWithPatternBrushVertexShader_core;
+
+static const char* const qopenglslPatternBrushSrcFragmentShader_core = "\n\
+    in      vec2      patternTexCoords;\n\
+    uniform sampler2D brushTexture; \n\
+    uniform vec4      patternColor; \n\
+    vec4 srcPixel() \n\
+    { \n\
+        return patternColor * (1.0 - texture(brushTexture, patternTexCoords).r); \n\
+    }\n";
+
+
+// Linear Gradient Brush
+static const char* const qopenglslPositionWithLinearGradientBrushVertexShader_core = "\n\
+    in      vec2      vertexCoordsArray; \n\
+    in      vec3      pmvMatrix1; \n\
+    in      vec3      pmvMatrix2; \n\
+    in      vec3      pmvMatrix3; \n\
+    out     float     index; \n\
+    uniform vec2      halfViewportSize; \n\
+    uniform vec3      linearData; \n\
+    uniform mat3      brushTransform; \n\
+    void setPosition() \n\
+    { \n\
+        mat3 pmvMatrix = mat3(pmvMatrix1, pmvMatrix2, pmvMatrix3); \n\
+        vec3 transformedPos = pmvMatrix * vec3(vertexCoordsArray.xy, 1.0); \n\
+        gl_Position.xy = transformedPos.xy / transformedPos.z; \n\
+        vec2 viewportCoords = (gl_Position.xy + 1.0) * halfViewportSize; \n\
+        vec3 hTexCoords = brushTransform * vec3(viewportCoords, 1); \n\
+        float invertedHTexCoordsZ = 1.0 / hTexCoords.z; \n\
+        gl_Position = vec4(gl_Position.xy * invertedHTexCoordsZ, 0.0, invertedHTexCoordsZ); \n\
+        index = (dot(linearData.xy, hTexCoords.xy) * linearData.z) * invertedHTexCoordsZ; \n\
+    }\n";
+
+static const char* const qopenglslAffinePositionWithLinearGradientBrushVertexShader_core
+                 = qopenglslPositionWithLinearGradientBrushVertexShader_core;
+
+static const char* const qopenglslLinearGradientBrushSrcFragmentShader_core = "\n\
+    uniform sampler2D brushTexture; \n\
+    in      float     index; \n\
+    vec4 srcPixel() \n\
+    { \n\
+        vec2 val = vec2(index, 0.5); \n\
+        return texture(brushTexture, val); \n\
+    }\n";
+
+
+// Conical Gradient Brush
+static const char* const qopenglslPositionWithConicalGradientBrushVertexShader_core = "\n\
+    in      vec2      vertexCoordsArray; \n\
+    in      vec3      pmvMatrix1; \n\
+    in      vec3      pmvMatrix2; \n\
+    in      vec3      pmvMatrix3; \n\
+    out     vec2      A; \n\
+    uniform vec2      halfViewportSize; \n\
+    uniform mat3      brushTransform; \n\
+    void setPosition(void) \n\
+    { \n\
+        mat3 pmvMatrix = mat3(pmvMatrix1, pmvMatrix2, pmvMatrix3); \n\
+        vec3 transformedPos = pmvMatrix * vec3(vertexCoordsArray.xy, 1.0); \n\
+        gl_Position.xy = transformedPos.xy / transformedPos.z; \n\
+        vec2  viewportCoords = (gl_Position.xy + 1.0) * halfViewportSize; \n\
+        vec3 hTexCoords = brushTransform * vec3(viewportCoords, 1); \n\
+        float invertedHTexCoordsZ = 1.0 / hTexCoords.z; \n\
+        gl_Position = vec4(gl_Position.xy * invertedHTexCoordsZ, 0.0, invertedHTexCoordsZ); \n\
+        A = hTexCoords.xy * invertedHTexCoordsZ; \n\
+    }\n";
+
+static const char* const qopenglslAffinePositionWithConicalGradientBrushVertexShader_core
+                 = qopenglslPositionWithConicalGradientBrushVertexShader_core;
+
+static const char* const qopenglslConicalGradientBrushSrcFragmentShader_core = "\n\
+    #define INVERSE_2PI 0.1591549430918953358 \n\
+    in      vec2      A; \n\
+    uniform sampler2D brushTexture; \n\
+    uniform float     angle; \n\
+    vec4 srcPixel() \n\
+    { \n\
+        float t; \n\
+        if (abs(A.y) == abs(A.x)) \n\
+            t = (atan(-A.y + 0.002, A.x) + angle) * INVERSE_2PI; \n\
+        else \n\
+            t = (atan(-A.y, A.x) + angle) * INVERSE_2PI; \n\
+        return texture(brushTexture, vec2(t - floor(t), 0.5)); \n\
+    }\n";
+
+
+// Radial Gradient Brush
+static const char* const qopenglslPositionWithRadialGradientBrushVertexShader_core = "\n\
+    in      vec2      vertexCoordsArray;\n\
+    in      vec3      pmvMatrix1; \n\
+    in      vec3      pmvMatrix2; \n\
+    in      vec3      pmvMatrix3; \n\
+    out     float     b; \n\
+    out     vec2      A; \n\
+    uniform vec2      halfViewportSize; \n\
+    uniform mat3      brushTransform; \n\
+    uniform vec2      fmp; \n\
+    uniform vec3      bradius; \n\
+    void setPosition(void) \n\
+    {\n\
+        mat3 pmvMatrix = mat3(pmvMatrix1, pmvMatrix2, pmvMatrix3); \n\
+        vec3 transformedPos = pmvMatrix * vec3(vertexCoordsArray.xy, 1.0); \n\
+        gl_Position.xy = transformedPos.xy / transformedPos.z; \n\
+        vec2 viewportCoords = (gl_Position.xy + 1.0) * halfViewportSize; \n\
+        vec3 hTexCoords = brushTransform * vec3(viewportCoords, 1); \n\
+        float invertedHTexCoordsZ = 1.0 / hTexCoords.z; \n\
+        gl_Position = vec4(gl_Position.xy * invertedHTexCoordsZ, 0.0, invertedHTexCoordsZ); \n\
+        A = hTexCoords.xy * invertedHTexCoordsZ; \n\
+        b = bradius.x + 2.0 * dot(A, fmp); \n\
+    }\n";
+
+static const char* const qopenglslAffinePositionWithRadialGradientBrushVertexShader_core
+                 = qopenglslPositionWithRadialGradientBrushVertexShader_core;
+
+static const char* const qopenglslRadialGradientBrushSrcFragmentShader_core = "\n\
+    in      float     b; \n\
+    in      vec2      A; \n\
+    uniform sampler2D brushTexture; \n\
+    uniform float     fmp2_m_radius2; \n\
+    uniform float     inverse_2_fmp2_m_radius2; \n\
+    uniform float     sqrfr; \n\
+    uniform vec3      bradius; \n\
+    \n\
+    vec4 srcPixel() \n\
+    { \n\
+        float c = sqrfr-dot(A, A); \n\
+        float det = b*b - 4.0*fmp2_m_radius2*c; \n\
+        vec4 result = vec4(0.0); \n\
+        if (det >= 0.0) { \n\
+            float detSqrt = sqrt(det); \n\
+            float w = max((-b - detSqrt) * inverse_2_fmp2_m_radius2, (-b + detSqrt) * inverse_2_fmp2_m_radius2); \n\
+            if (bradius.y + w * bradius.z >= 0.0) \n\
+                result = texture(brushTexture, vec2(w, 0.5)); \n\
+        } \n\
+        return result; \n\
+    }\n";
+
+
+// Texture Brush
+static const char* const qopenglslPositionWithTextureBrushVertexShader_core = "\n\
+    in      vec2      vertexCoordsArray; \n\
+    in      vec3      pmvMatrix1; \n\
+    in      vec3      pmvMatrix2; \n\
+    in      vec3      pmvMatrix3; \n\
+    out     vec2      brushTextureCoords; \n\
+    uniform vec2      halfViewportSize; \n\
+    uniform vec2      invertedTextureSize; \n\
+    uniform mat3      brushTransform; \n\
+    \n\
+    void setPosition(void) \n\
+    { \n\
+        mat3 pmvMatrix = mat3(pmvMatrix1, pmvMatrix2, pmvMatrix3); \n\
+        vec3 transformedPos = pmvMatrix * vec3(vertexCoordsArray.xy, 1.0); \n\
+        gl_Position.xy = transformedPos.xy / transformedPos.z; \n\
+        vec2 viewportCoords = (gl_Position.xy + 1.0) * halfViewportSize; \n\
+        vec3 hTexCoords = brushTransform * vec3(viewportCoords, 1); \n\
+        float invertedHTexCoordsZ = 1.0 / hTexCoords.z; \n\
+        gl_Position = vec4(gl_Position.xy * invertedHTexCoordsZ, 0.0, invertedHTexCoordsZ); \n\
+        brushTextureCoords.xy = (hTexCoords.xy * invertedTextureSize) * gl_Position.w; \n\
+    }\n";
+
+static const char* const qopenglslAffinePositionWithTextureBrushVertexShader_core
+                 = qopenglslPositionWithTextureBrushVertexShader_core;
+
+static const char* const qopenglslTextureBrushSrcFragmentShader_core = "\n\
+    in      vec2      brushTextureCoords; \n\
+    uniform sampler2D brushTexture; \n\
+    vec4 srcPixel() \n\
+    { \n\
+        return texture(brushTexture, brushTextureCoords); \n\
+    }\n";
+
+static const char* const qopenglslTextureBrushSrcWithPatternFragmentShader_core = "\n\
+    in      vec2      brushTextureCoords; \n\
+    uniform vec4      patternColor; \n\
+    uniform sampler2D brushTexture; \n\
+    vec4 srcPixel() \n\
+    { \n\
+        return patternColor * (1.0 - texture(brushTexture, brushTextureCoords).r); \n\
+    }\n";
+
+// Solid Fill Brush
+static const char* const qopenglslSolidBrushSrcFragmentShader_core = "\n\
+    uniform vec4      fragmentColor; \n\
+    vec4 srcPixel() \n\
+    { \n\
+        return fragmentColor; \n\
+    }\n";
+
+static const char* const qopenglslImageSrcFragmentShader_core = "\n\
+    in      vec2      textureCoords; \n\
+    uniform sampler2D imageTexture; \n\
+    vec4 srcPixel() \n\
+    { \n\
+        return texture(imageTexture, textureCoords); \n\
+    }\n";
+
+static const char* const qopenglslCustomSrcFragmentShader_core = "\n\
+    in      vec2      textureCoords; \n\
+    uniform sampler2D imageTexture; \n\
+    vec4 srcPixel() \n\
+    { \n\
+        return customShader(imageTexture, textureCoords); \n\
+    }\n";
+
+static const char* const qopenglslImageSrcWithPatternFragmentShader_core = "\n\
+    in      vec2      textureCoords; \n\
+    uniform vec4      patternColor; \n\
+    uniform sampler2D imageTexture; \n\
+    vec4 srcPixel() \n\
+    { \n\
+        return patternColor * (1.0 - texture(imageTexture, textureCoords).r); \n\
+    }\n";
+
+static const char* const qopenglslNonPremultipliedImageSrcFragmentShader_core = "\n\
+    in      vec2      textureCoords; \n\
+    uniform sampler2D imageTexture; \n\
+    vec4 srcPixel() \n\
+    { \n\
+        vec4 sample = texture(imageTexture, textureCoords); \n\
+        sample.rgb = sample.rgb * sample.a; \n\
+        return sample; \n\
+    }\n";
+
+static const char* const qopenglslGrayscaleImageSrcFragmentShader_core = "\n\
+    in      vec2      textureCoords; \n\
+    uniform sampler2D imageTexture; \n\
+    vec4 srcPixel() \n\
+    { \n\
+        return texture(imageTexture, textureCoords).rrra; \n\
+    }\n";
+
+static const char* const qopenglslAlphaImageSrcFragmentShader_core = "\n\
+    in      vec2      textureCoords; \n\
+    uniform sampler2D imageTexture; \n\
+    vec4 srcPixel() \n\
+    { \n\
+        return vec4(0, 0, 0, texture(imageTexture, textureCoords).r); \n\
+    }\n";
+
+static const char* const qopenglslShockingPinkSrcFragmentShader_core = "\n\
+    vec4 srcPixel() \n\
+    { \n\
+        return vec4(0.98, 0.06, 0.75, 1.0); \n\
+    }\n";
+
+static const char* const qopenglslMainFragmentShader_ImageArrays_core =
+    "#version 150 core\n\
+    in      float     opacity; \n\
+    out     vec4      fragColor; \n\
+    vec4 srcPixel(); \n\
+    void main() \n\
+    { \n\
+        fragColor = srcPixel() * opacity; \n\
+    }\n";
+
+static const char* const qopenglslMainFragmentShader_MO_core =
+    "#version 150 core\n\
+    out     vec4      fragColor; \n\
+    uniform float     globalOpacity; \n\
+    vec4 srcPixel(); \n\
+    vec4 applyMask(vec4); \n\
+    void main() \n\
+    { \n\
+        fragColor = applyMask(srcPixel()*globalOpacity); \n\
+    }\n";
+
+static const char* const qopenglslMainFragmentShader_M_core =
+    "#version 150 core\n\
+    out     vec4      fragColor; \n\
+    vec4 srcPixel(); \n\
+    vec4 applyMask(vec4); \n\
+    void main() \n\
+    { \n\
+        fragColor = applyMask(srcPixel()); \n\
+    }\n";
+
+static const char* const qopenglslMainFragmentShader_O_core =
+    "#version 150 core\n\
+    out     vec4      fragColor; \n\
+    uniform float     globalOpacity; \n\
+    vec4 srcPixel(); \n\
+    void main() \n\
+    { \n\
+        fragColor = srcPixel()*globalOpacity; \n\
+    }\n";
+
+static const char* const qopenglslMainFragmentShader_core =
+    "#version 150 core\n\
+    out     vec4      fragColor; \n\
+    vec4 srcPixel(); \n\
+    void main() \n\
+    { \n\
+        fragColor = srcPixel(); \n\
+    }\n";
+
+static const char* const qopenglslMaskFragmentShader_core = "\n\
+    in      vec2      textureCoords;\n\
+    uniform sampler2D maskTexture;\n\
+    vec4 applyMask(vec4 src) \n\
+    {\n\
+        vec4 mask = texture(maskTexture, textureCoords); \n\
+        return src * mask.r; \n\
+    }\n";
+
+// For source over with subpixel antialiasing, the final color is calculated per component as follows
+// (.a is alpha component, .c is red, green or blue component):
+// alpha = src.a * mask.c * opacity
+// dest.c = dest.c * (1 - alpha) + src.c * alpha
+//
+// In the first pass, calculate: dest.c = dest.c * (1 - alpha) with blend funcs: zero, 1 - source color
+// In the second pass, calculate: dest.c = dest.c + src.c * alpha with blend funcs: one, one
+//
+// If source is a solid color (src is constant), only the first pass is needed, with blend funcs: constant, 1 - source color
+
+// For source composition with subpixel antialiasing, the final color is calculated per component as follows:
+// alpha = src.a * mask.c * opacity
+// dest.c = dest.c * (1 - mask.c) + src.c * alpha
+//
+
+static const char* const qopenglslRgbMaskFragmentShaderPass1_core = "\n\
+    in      vec2      textureCoords;\n\
+    uniform sampler2D maskTexture;\n\
+    vec4 applyMask(vec4 src) \n\
+    { \n\
+        vec4 mask = texture(maskTexture, textureCoords); \n\
+        return src.a * mask; \n\
+    }\n";
+
+static const char* const qopenglslRgbMaskFragmentShaderPass2_core = "\n\
+    in      vec2      textureCoords;\n\
+    uniform sampler2D maskTexture;\n\
+    vec4 applyMask(vec4 src) \n\
+    { \n\
+        vec4 mask = texture(maskTexture, textureCoords); \n\
+        return src * mask; \n\
+    }\n";
+
+/*
+    Left to implement:
+        RgbMaskFragmentShader_core,
+        RgbMaskWithGammaFragmentShader_core,
+*/
+
+QT_END_NAMESPACE
+
+#endif // GLGC_SHADER_SOURCE_H
diff --git a/src/opengl/qopenglgradientcache.cpp b/src/opengl/qopenglgradientcache.cpp
new file mode 100644
index 0000000000..7a932a19bb
--- /dev/null
+++ b/src/opengl/qopenglgradientcache.cpp
@@ -0,0 +1,276 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtOpenGL module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qopenglgradientcache_p.h"
+#include <private/qdrawhelper_p.h>
+#include <private/qopenglcontext_p.h>
+#include <private/qrgba64_p.h>
+#include <QtCore/qmutex.h>
+#include <QtCore/qrandom.h>
+#include "qopenglfunctions.h"
+#include <private/qopenglextensions_p.h>
+
+#ifndef GL_RGBA16
+#define GL_RGBA16   0x805B
+#endif
+
+QT_BEGIN_NAMESPACE
+
+class QOpenGL2GradientCacheWrapper
+{
+public:
+    QOpenGL2GradientCache *cacheForContext(QOpenGLContext *context) {
+        QMutexLocker lock(&m_mutex);
+        return m_resource.value<QOpenGL2GradientCache>(context);
+    }
+
+private:
+    QOpenGLMultiGroupSharedResource m_resource;
+    QMutex m_mutex;
+};
+
+Q_GLOBAL_STATIC(QOpenGL2GradientCacheWrapper, qt_gradient_caches)
+
+QOpenGL2GradientCache::QOpenGL2GradientCache(QOpenGLContext *ctx)
+    : QOpenGLSharedResource(ctx->shareGroup())
+{
+}
+
+QOpenGL2GradientCache::~QOpenGL2GradientCache()
+{
+    cache.clear();
+}
+
+QOpenGL2GradientCache *QOpenGL2GradientCache::cacheForContext(QOpenGLContext *context)
+{
+    return qt_gradient_caches()->cacheForContext(context);
+}
+
+void QOpenGL2GradientCache::invalidateResource()
+{
+    QMutexLocker lock(&m_mutex);
+    cache.clear();
+}
+
+void QOpenGL2GradientCache::freeResource(QOpenGLContext *)
+{
+    cleanCache();
+}
+
+void QOpenGL2GradientCache::cleanCache()
+{
+    QMutexLocker lock(&m_mutex);
+    QOpenGLGradientColorTableHash::const_iterator it = cache.constBegin();
+    QOpenGLFunctions *funcs = QOpenGLContext::currentContext()->functions();
+    for (; it != cache.constEnd(); ++it) {
+        const CacheInfo &cache_info = it.value();
+        funcs->glDeleteTextures(1, &cache_info.texId);
+    }
+    cache.clear();
+}
+
+GLuint QOpenGL2GradientCache::getBuffer(const QGradient &gradient, qreal opacity)
+{
+    quint64 hash_val = 0;
+
+    const QGradientStops stops = gradient.stops();
+    for (int i = 0; i < stops.size() && i <= 2; i++)
+        hash_val += stops[i].second.rgba();
+
+    const QMutexLocker lock(&m_mutex);
+    QOpenGLGradientColorTableHash::const_iterator it = cache.constFind(hash_val);
+
+    if (it == cache.constEnd())
+        return addCacheElement(hash_val, gradient, opacity);
+    else {
+        do {
+            const CacheInfo &cache_info = it.value();
+            if (cache_info.stops == stops && cache_info.opacity == opacity
+                && cache_info.interpolationMode == gradient.interpolationMode())
+            {
+                return cache_info.texId;
+            }
+            ++it;
+        } while (it != cache.constEnd() && it.key() == hash_val);
+        // an exact match for these stops and opacity was not found, create new cache
+        return addCacheElement(hash_val, gradient, opacity);
+    }
+}
+
+
+GLuint QOpenGL2GradientCache::addCacheElement(quint64 hash_val, const QGradient &gradient, qreal opacity)
+{
+    QOpenGLFunctions *funcs = QOpenGLContext::currentContext()->functions();
+    if (cache.size() == maxCacheSize()) {
+        int elem_to_remove = QRandomGenerator::global()->bounded(maxCacheSize());
+        quint64 key = cache.keys()[elem_to_remove];
+
+        // need to call glDeleteTextures on each removed cache entry:
+        QOpenGLGradientColorTableHash::const_iterator it = cache.constFind(key);
+        do {
+            funcs->glDeleteTextures(1, &it.value().texId);
+        } while (++it != cache.constEnd() && it.key() == key);
+        cache.remove(key); // may remove more than 1, but OK
+    }
+
+    CacheInfo cache_entry(gradient.stops(), opacity, gradient.interpolationMode());
+    funcs->glGenTextures(1, &cache_entry.texId);
+    funcs->glBindTexture(GL_TEXTURE_2D, cache_entry.texId);
+    if (static_cast<QOpenGLExtensions *>(funcs)->hasOpenGLExtension(QOpenGLExtensions::Sized16Formats)) {
+        QRgba64 buffer[1024];
+        generateGradientColorTable(gradient, buffer, paletteSize(), opacity);
+        funcs->glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA16, paletteSize(), 1,
+                            0, GL_RGBA, GL_UNSIGNED_SHORT, buffer);
+    } else {
+        uint buffer[1024];
+        generateGradientColorTable(gradient, buffer, paletteSize(), opacity);
+        funcs->glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, paletteSize(), 1,
+                            0, GL_RGBA, GL_UNSIGNED_BYTE, buffer);
+    }
+    return cache.insert(hash_val, cache_entry).value().texId;
+}
+
+
+//TODO: Let GL generate the texture using an FBO
+void QOpenGL2GradientCache::generateGradientColorTable(const QGradient& gradient, QRgba64 *colorTable, int size, qreal opacity) const
+{
+    int pos = 0;
+    const QGradientStops s = gradient.stops();
+
+    bool colorInterpolation = (gradient.interpolationMode() == QGradient::ColorInterpolation);
+
+    uint alpha = qRound(opacity * 256);
+    QRgba64 current_color = combineAlpha256(s[0].second.rgba64(), alpha);
+    qreal incr = 1.0 / qreal(size);
+    qreal fpos = 1.5 * incr;
+    colorTable[pos++] = qPremultiply(current_color);
+
+    while (fpos <= s.first().first) {
+        colorTable[pos] = colorTable[pos - 1];
+        pos++;
+        fpos += incr;
+    }
+
+    if (colorInterpolation)
+        current_color = qPremultiply(current_color);
+
+    const int sLast = s.size() - 1;
+    for (int i = 0; i < sLast; ++i) {
+        qreal delta = 1/(s[i+1].first - s[i].first);
+        QRgba64 next_color = combineAlpha256(s[i + 1].second.rgba64(), alpha);
+        if (colorInterpolation)
+            next_color = qPremultiply(next_color);
+
+        while (fpos < s[i+1].first && pos < size) {
+            int dist = int(256 * ((fpos - s[i].first) * delta));
+            int idist = 256 - dist;
+            if (colorInterpolation)
+                colorTable[pos] = interpolate256(current_color, idist, next_color, dist);
+            else
+                colorTable[pos] = qPremultiply(interpolate256(current_color, idist, next_color, dist));
+            ++pos;
+            fpos += incr;
+        }
+        current_color = next_color;
+    }
+
+    Q_ASSERT(s.size() > 0);
+
+    QRgba64 last_color = qPremultiply(combineAlpha256(s[sLast].second.rgba64(), alpha));
+    for (;pos < size; ++pos)
+        colorTable[pos] = last_color;
+
+    // Make sure the last color stop is represented at the end of the table
+    colorTable[size-1] = last_color;
+}
+
+void QOpenGL2GradientCache::generateGradientColorTable(const QGradient& gradient, uint *colorTable, int size, qreal opacity) const
+{
+    int pos = 0;
+    const QGradientStops s = gradient.stops();
+
+    bool colorInterpolation = (gradient.interpolationMode() == QGradient::ColorInterpolation);
+
+    uint alpha = qRound(opacity * 256);
+    // Qt LIES! It returns ARGB (on little-endian AND on big-endian)
+    uint current_color = ARGB_COMBINE_ALPHA(s[0].second.rgba(), alpha);
+    qreal incr = 1.0 / qreal(size);
+    qreal fpos = 1.5 * incr;
+    colorTable[pos++] = ARGB2RGBA(qPremultiply(current_color));
+
+    while (fpos <= s.first().first) {
+        colorTable[pos] = colorTable[pos - 1];
+        pos++;
+        fpos += incr;
+    }
+
+    if (colorInterpolation)
+        current_color = qPremultiply(current_color);
+
+    const int sLast = s.size() - 1;
+    for (int i = 0; i < sLast; ++i) {
+        qreal delta = 1/(s[i+1].first - s[i].first);
+        uint next_color = ARGB_COMBINE_ALPHA(s[i + 1].second.rgba(), alpha);
+        if (colorInterpolation)
+            next_color = qPremultiply(next_color);
+
+        while (fpos < s[i+1].first && pos < size) {
+            int dist = int(256 * ((fpos - s[i].first) * delta));
+            int idist = 256 - dist;
+            if (colorInterpolation)
+                colorTable[pos] = ARGB2RGBA(INTERPOLATE_PIXEL_256(current_color, idist, next_color, dist));
+            else
+                colorTable[pos] = ARGB2RGBA(qPremultiply(INTERPOLATE_PIXEL_256(current_color, idist, next_color, dist)));
+            ++pos;
+            fpos += incr;
+        }
+        current_color = next_color;
+    }
+
+    Q_ASSERT(s.size() > 0);
+
+    uint last_color = ARGB2RGBA(qPremultiply(ARGB_COMBINE_ALPHA(s[sLast].second.rgba(), alpha)));
+    for (;pos < size; ++pos)
+        colorTable[pos] = last_color;
+
+    // Make sure the last color stop is represented at the end of the table
+    colorTable[size-1] = last_color;
+}
+
+QT_END_NAMESPACE
diff --git a/src/opengl/qopenglgradientcache_p.h b/src/opengl/qopenglgradientcache_p.h
new file mode 100644
index 0000000000..da070ae233
--- /dev/null
+++ b/src/opengl/qopenglgradientcache_p.h
@@ -0,0 +1,107 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtOpenGL module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QOPENGLGRADIENTCACHE_P_H
+#define QOPENGLGRADIENTCACHE_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QMultiHash>
+#include <QObject>
+#include <private/qopenglcontext_p.h>
+#include <QtCore/qmutex.h>
+#include <QGradient>
+#include <qrgba64.h>
+
+QT_BEGIN_NAMESPACE
+
+class QOpenGL2GradientCache : public QOpenGLSharedResource
+{
+    struct CacheInfo
+    {
+        inline CacheInfo(QGradientStops s, qreal op, QGradient::InterpolationMode mode) :
+            stops(std::move(s)), opacity(op), interpolationMode(mode) {}
+
+        GLuint texId;
+        QGradientStops stops;
+        qreal opacity;
+        QGradient::InterpolationMode interpolationMode;
+    };
+
+    typedef QMultiHash<quint64, CacheInfo> QOpenGLGradientColorTableHash;
+
+public:
+    static QOpenGL2GradientCache *cacheForContext(QOpenGLContext *context);
+
+    QOpenGL2GradientCache(QOpenGLContext *);
+    ~QOpenGL2GradientCache();
+
+    GLuint getBuffer(const QGradient &gradient, qreal opacity);
+    inline int paletteSize() const { return 1024; }
+
+    void invalidateResource() override;
+    void freeResource(QOpenGLContext *ctx) override;
+
+private:
+    inline int maxCacheSize() const { return 60; }
+    inline void generateGradientColorTable(const QGradient& gradient,
+                                           QRgba64 *colorTable,
+                                           int size, qreal opacity) const;
+    inline void generateGradientColorTable(const QGradient& gradient,
+                                           uint *colorTable,
+                                           int size, qreal opacity) const;
+    GLuint addCacheElement(quint64 hash_val, const QGradient &gradient, qreal opacity);
+    void cleanCache();
+
+    QOpenGLGradientColorTableHash cache;
+    QMutex m_mutex;
+};
+
+QT_END_NAMESPACE
+
+#endif // QOPENGLGRADIENTCACHE_P_H
diff --git a/src/opengl/qopenglpaintdevice.cpp b/src/opengl/qopenglpaintdevice.cpp
new file mode 100644
index 0000000000..811425cf69
--- /dev/null
+++ b/src/opengl/qopenglpaintdevice.cpp
@@ -0,0 +1,372 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtOpenGL module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <qopenglpaintdevice.h>
+#include <qpaintengine.h>
+#include <qthreadstorage.h>
+
+#include <private/qopenglpaintdevice_p.h>
+#include <private/qobject_p.h>
+#include <private/qopenglcontext_p.h>
+#include <private/qopenglframebufferobject_p.h>
+#include <private/qopenglpaintengine_p.h>
+
+// for qt_defaultDpiX/Y
+#include <private/qfont_p.h>
+
+#include <qopenglfunctions.h>
+
+QT_BEGIN_NAMESPACE
+
+/*!
+    \class QOpenGLPaintDevice
+    \brief The QOpenGLPaintDevice class enables painting to an OpenGL context using QPainter.
+    \since 5.0
+    \inmodule QtOpenGL
+
+    \ingroup painting-3D
+
+    The QOpenGLPaintDevice uses the \b current QOpenGL context to render
+    QPainter draw commands. The context is captured upon construction. It
+    requires support for OpenGL (ES) 2.0 or higher.
+
+    \section1 Performance
+
+    The QOpenGLPaintDevice is almost always hardware accelerated and
+    has the potential of being much faster than software
+    rasterization. However, it is more sensitive to state changes, and
+    therefore requires the drawing commands to be carefully ordered to
+    achieve optimal performance.
+
+    \section1 Antialiasing and Quality
+
+    Antialiasing in the OpenGL paint engine is done using
+    multisampling. Most hardware require significantly more memory to
+    do multisampling and the resulting quality is not on par with the
+    quality of the software paint engine. The OpenGL paint engine's
+    strength lies in its performance, not its visual rendering
+    quality.
+
+    \section1 State Changes
+
+    When painting to a QOpenGLPaintDevice using QPainter, the state of
+    the current OpenGL context will be altered by the paint engine to
+    reflect its needs.  Applications should not rely upon the OpenGL
+    state being reset to its original conditions, particularly the
+    current shader program, OpenGL viewport, texture units, and
+    drawing modes.
+
+    \section1 Mixing QPainter and OpenGL
+
+    When intermixing QPainter and OpenGL, it is important to notify
+    QPainter that the OpenGL state may have been cluttered so it can
+    restore its internal state. This is achieved by calling \l
+    QPainter::beginNativePainting() before starting the OpenGL
+    rendering and calling \l QPainter::endNativePainting() after
+    finishing.
+
+    \sa {OpenGL Window Example}
+
+*/
+
+/*!
+    Constructs a QOpenGLPaintDevice.
+
+    The QOpenGLPaintDevice is only valid for the current context.
+
+    \sa QOpenGLContext::currentContext()
+*/
+QOpenGLPaintDevice::QOpenGLPaintDevice()
+    : d_ptr(new QOpenGLPaintDevicePrivate(QSize()))
+{
+}
+
+/*!
+    Constructs a QOpenGLPaintDevice with the given \a size.
+
+    The QOpenGLPaintDevice is only valid for the current context.
+
+    \sa QOpenGLContext::currentContext()
+*/
+QOpenGLPaintDevice::QOpenGLPaintDevice(const QSize &size)
+    : d_ptr(new QOpenGLPaintDevicePrivate(size))
+{
+}
+
+/*!
+    Constructs a QOpenGLPaintDevice with the given \a width and \a height.
+
+    The QOpenGLPaintDevice is only valid for the current context.
+
+    \sa QOpenGLContext::currentContext()
+*/
+QOpenGLPaintDevice::QOpenGLPaintDevice(int width, int height)
+    : QOpenGLPaintDevice(QSize(width, height))
+{
+}
+
+/*!
+    \internal
+ */
+QOpenGLPaintDevice::QOpenGLPaintDevice(QOpenGLPaintDevicePrivate &dd)
+    : d_ptr(&dd)
+{
+}
+
+/*!
+    Destroys the QOpenGLPaintDevice.
+*/
+
+QOpenGLPaintDevice::~QOpenGLPaintDevice()
+{
+    delete d_ptr->engine;
+}
+
+/*!
+    \fn int QOpenGLPaintDevice::devType() const
+    \internal
+    \reimp
+*/
+
+QOpenGLPaintDevicePrivate::QOpenGLPaintDevicePrivate(const QSize &sz)
+    : size(sz)
+    , ctx(QOpenGLContext::currentContext())
+    , dpmx(qt_defaultDpiX() * 100. / 2.54)
+    , dpmy(qt_defaultDpiY() * 100. / 2.54)
+    , devicePixelRatio(1.0)
+    , flipped(false)
+    , engine(nullptr)
+{
+}
+
+QOpenGLPaintDevicePrivate::~QOpenGLPaintDevicePrivate()
+{
+}
+
+class QOpenGLEngineThreadStorage
+{
+public:
+    QPaintEngine *engine() {
+        QPaintEngine *&localEngine = storage.localData();
+        if (!localEngine)
+            localEngine = new QOpenGL2PaintEngineEx;
+        return localEngine;
+    }
+
+private:
+    QThreadStorage<QPaintEngine *> storage;
+};
+
+Q_GLOBAL_STATIC(QOpenGLEngineThreadStorage, qt_opengl_engine)
+
+/*!
+    \reimp
+*/
+
+QPaintEngine *QOpenGLPaintDevice::paintEngine() const
+{
+    if (d_ptr->engine)
+        return d_ptr->engine;
+
+    QPaintEngine *engine = qt_opengl_engine()->engine();
+    if (engine->isActive() && engine->paintDevice() != this) {
+        d_ptr->engine = new QOpenGL2PaintEngineEx;
+        return d_ptr->engine;
+    }
+
+    return engine;
+}
+
+/*!
+    Returns the OpenGL context associated with the paint device.
+*/
+
+QOpenGLContext *QOpenGLPaintDevice::context() const
+{
+    return d_ptr->ctx;
+}
+
+/*!
+    Returns the pixel size of the paint device.
+
+    \sa setSize()
+*/
+
+QSize QOpenGLPaintDevice::size() const
+{
+    return d_ptr->size;
+}
+
+/*!
+    Sets the pixel size of the paint device to \a size.
+
+    \sa size()
+*/
+
+void QOpenGLPaintDevice::setSize(const QSize &size)
+{
+    d_ptr->size = size;
+}
+
+/*!
+    Sets the device pixel ratio for the paint device to \a devicePixelRatio.
+*/
+void QOpenGLPaintDevice::setDevicePixelRatio(qreal devicePixelRatio)
+{
+    d_ptr->devicePixelRatio = devicePixelRatio;
+}
+
+/*!
+    \reimp
+*/
+
+int QOpenGLPaintDevice::metric(QPaintDevice::PaintDeviceMetric metric) const
+{
+    switch (metric) {
+    case PdmWidth:
+        return d_ptr->size.width();
+    case PdmHeight:
+        return d_ptr->size.height();
+    case PdmDepth:
+        return 32;
+    case PdmWidthMM:
+        return qRound(d_ptr->size.width() * 1000 / d_ptr->dpmx);
+    case PdmHeightMM:
+        return qRound(d_ptr->size.height() * 1000 / d_ptr->dpmy);
+    case PdmNumColors:
+        return 0;
+    case PdmDpiX:
+        return qRound(d_ptr->dpmx * 0.0254);
+    case PdmDpiY:
+        return qRound(d_ptr->dpmy * 0.0254);
+    case PdmPhysicalDpiX:
+        return qRound(d_ptr->dpmx * 0.0254);
+    case PdmPhysicalDpiY:
+        return qRound(d_ptr->dpmy * 0.0254);
+    case PdmDevicePixelRatio:
+        return d_ptr->devicePixelRatio;
+    case PdmDevicePixelRatioScaled:
+        return d_ptr->devicePixelRatio * QPaintDevice::devicePixelRatioFScale();
+
+    default:
+        qWarning("QOpenGLPaintDevice::metric() - metric %d not known", metric);
+        return 0;
+    }
+}
+
+/*!
+    Returns the number of pixels per meter horizontally.
+
+    \sa setDotsPerMeterX()
+*/
+
+qreal QOpenGLPaintDevice::dotsPerMeterX() const
+{
+    return d_ptr->dpmx;
+}
+
+/*!
+    Returns the number of pixels per meter vertically.
+
+    \sa setDotsPerMeterY()
+*/
+
+qreal QOpenGLPaintDevice::dotsPerMeterY() const
+{
+    return d_ptr->dpmy;
+}
+
+/*!
+    Sets the number of pixels per meter horizontally to \a dpmx.
+
+    \sa dotsPerMeterX()
+*/
+
+void QOpenGLPaintDevice::setDotsPerMeterX(qreal dpmx)
+{
+    d_ptr->dpmx = dpmx;
+}
+
+/*!
+    Sets the number of pixels per meter vertically to \a dpmy.
+
+    \sa dotsPerMeterY()
+*/
+
+void QOpenGLPaintDevice::setDotsPerMeterY(qreal dpmy)
+{
+    d_ptr->dpmx = dpmy;
+}
+
+/*!
+    Sets whether painting should be flipped around the Y-axis or not to \a flipped.
+
+    \sa paintFlipped()
+*/
+void QOpenGLPaintDevice::setPaintFlipped(bool flipped)
+{
+    d_ptr->flipped = flipped;
+}
+
+/*!
+    Returns \c true if painting is flipped around the Y-axis.
+
+    \sa setPaintFlipped()
+*/
+
+bool QOpenGLPaintDevice::paintFlipped() const
+{
+    return d_ptr->flipped;
+}
+
+/*!
+    This virtual method is provided as a callback to allow re-binding a target
+    frame buffer object or context when different QOpenGLPaintDevice instances
+    are issuing draw calls alternately.
+
+    \l{QPainter::beginNativePainting()}{beginNativePainting()} will also trigger
+    this method.
+
+    The default implementation does nothing.
+*/
+void QOpenGLPaintDevice::ensureActiveTarget()
+{
+}
+
+QT_END_NAMESPACE
diff --git a/src/opengl/qopenglpaintdevice.h b/src/opengl/qopenglpaintdevice.h
new file mode 100644
index 0000000000..f4e1ce4a2e
--- /dev/null
+++ b/src/opengl/qopenglpaintdevice.h
@@ -0,0 +1,95 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtOpenGL module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QOPENGLPAINTDEVICE_H
+#define QOPENGLPAINTDEVICE_H
+
+#include <QtOpenGL/qtopenglglobal.h>
+
+#ifndef QT_NO_OPENGL
+
+#include <QtGui/qpaintdevice.h>
+#include <QtGui/qopengl.h>
+#include <QtGui/qopenglcontext.h>
+
+QT_BEGIN_NAMESPACE
+
+class QOpenGLPaintDevicePrivate;
+
+class Q_OPENGL_EXPORT QOpenGLPaintDevice : public QPaintDevice
+{
+    Q_DECLARE_PRIVATE(QOpenGLPaintDevice)
+public:
+    QOpenGLPaintDevice();
+    explicit QOpenGLPaintDevice(const QSize &size);
+    QOpenGLPaintDevice(int width, int height);
+    ~QOpenGLPaintDevice();
+
+    int devType() const override { return QInternal::OpenGL; }
+    QPaintEngine *paintEngine() const override;
+
+    QOpenGLContext *context() const;
+    QSize size() const;
+    void setSize(const QSize &size);
+    void setDevicePixelRatio(qreal devicePixelRatio);
+
+    qreal dotsPerMeterX() const;
+    qreal dotsPerMeterY() const;
+
+    void setDotsPerMeterX(qreal);
+    void setDotsPerMeterY(qreal);
+
+    void setPaintFlipped(bool flipped);
+    bool paintFlipped() const;
+
+    virtual void ensureActiveTarget();
+
+protected:
+    QOpenGLPaintDevice(QOpenGLPaintDevicePrivate &dd);
+    int metric(QPaintDevice::PaintDeviceMetric metric) const override;
+
+    Q_DISABLE_COPY(QOpenGLPaintDevice)
+    QScopedPointer<QOpenGLPaintDevicePrivate> d_ptr;
+};
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_OPENGL
+
+#endif // QOPENGLPAINTDEVICE_H
diff --git a/src/opengl/qopenglpaintdevice_p.h b/src/opengl/qopenglpaintdevice_p.h
new file mode 100644
index 0000000000..f4f02e7b57
--- /dev/null
+++ b/src/opengl/qopenglpaintdevice_p.h
@@ -0,0 +1,87 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtOpenGL module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QOPENGL_PAINTDEVICE_P_H
+#define QOPENGL_PAINTDEVICE_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of the Qt OpenGL classes.  This header file may change from
+// version to version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <qopenglpaintdevice.h>
+
+QT_BEGIN_NAMESPACE
+
+class QOpenGLContext;
+class QPaintEngine;
+
+class Q_OPENGL_EXPORT QOpenGLPaintDevicePrivate
+{
+public:
+    QOpenGLPaintDevicePrivate(const QSize &size);
+    virtual ~QOpenGLPaintDevicePrivate();
+
+    static QOpenGLPaintDevicePrivate *get(QOpenGLPaintDevice *dev) { return dev->d_func(); }
+
+    virtual void beginPaint() { }
+    virtual void endPaint() { }
+
+public:
+    QSize size;
+    QOpenGLContext *ctx;
+
+    qreal dpmx;
+    qreal dpmy;
+    qreal devicePixelRatio;
+
+    bool flipped;
+
+    QPaintEngine *engine;
+};
+
+QT_END_NAMESPACE
+
+#endif // QOPENGL_PAINTDEVICE_P_H
diff --git a/src/opengl/qopenglpaintengine.cpp b/src/opengl/qopenglpaintengine.cpp
new file mode 100644
index 0000000000..4168067e8f
--- /dev/null
+++ b/src/opengl/qopenglpaintengine.cpp
@@ -0,0 +1,2702 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtOpenGL module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*
+    When the active program changes, we need to update it's uniforms.
+    We could track state for each program and only update stale uniforms
+        - Could lead to lots of overhead if there's a lot of programs
+    We could update all the uniforms when the program changes
+        - Could end up updating lots of uniforms which don't need updating
+
+    Updating uniforms should be cheap, so the overhead of updating up-to-date
+    uniforms should be minimal. It's also less complex.
+
+    Things which _may_ cause a different program to be used:
+        - Change in brush/pen style
+        - Change in painter opacity
+        - Change in composition mode
+
+    Whenever we set a mode on the shader manager - it needs to tell us if it had
+    to switch to a different program.
+
+    The shader manager should only switch when we tell it to. E.g. if we set a new
+    brush style and then switch to transparent painter, we only want it to compile
+    and use the correct program when we really need it.
+*/
+
+// #define QT_OPENGL_CACHE_AS_VBOS
+
+#include <private/qopenglgradientcache_p.h>
+#include <private/qopengltexturecache_p.h>
+#include "qopenglpaintengine_p.h"
+#include "qopenglpaintdevice_p.h"
+
+#include <string.h> //for memcpy
+#include <qmath.h>
+
+#include <private/qopengl_p.h>
+#include <private/qopenglcontext_p.h>
+#include <private/qopenglextensions_p.h>
+#include <private/qpaintengineex_p.h>
+#include <QPaintEngine>
+#include <private/qpainter_p.h>
+#include <private/qfontengine_p.h>
+#include <private/qdatabuffer_p.h>
+#include <private/qstatictext_p.h>
+#include <private/qtriangulator_p.h>
+
+#include <private/qopenglengineshadermanager_p.h>
+#include <private/qopengl2pexvertexarray_p.h>
+#include <private/qopengltextureglyphcache_p.h>
+
+#include <QDebug>
+
+#ifndef GL_KHR_blend_equation_advanced
+#define GL_KHR_blend_equation_advanced 1
+#define GL_MULTIPLY_KHR                   0x9294
+#define GL_SCREEN_KHR                     0x9295
+#define GL_OVERLAY_KHR                    0x9296
+#define GL_DARKEN_KHR                     0x9297
+#define GL_LIGHTEN_KHR                    0x9298
+#define GL_COLORDODGE_KHR                 0x9299
+#define GL_COLORBURN_KHR                  0x929A
+#define GL_HARDLIGHT_KHR                  0x929B
+#define GL_SOFTLIGHT_KHR                  0x929C
+#define GL_DIFFERENCE_KHR                 0x929E
+#define GL_EXCLUSION_KHR                  0x92A0
+#endif /* GL_KHR_blend_equation_advanced */
+
+#ifndef GL_KHR_blend_equation_advanced_coherent
+#define GL_KHR_blend_equation_advanced_coherent 1
+#define GL_BLEND_ADVANCED_COHERENT_KHR    0x9285
+#endif /* GL_KHR_blend_equation_advanced_coherent */
+
+QT_BEGIN_NAMESPACE
+
+
+Q_OPENGL_EXPORT QImage qt_imageForBrush(int brushStyle, bool invert);
+
+////////////////////////////////// Private Methods //////////////////////////////////////////
+
+QOpenGL2PaintEngineExPrivate::~QOpenGL2PaintEngineExPrivate()
+{
+    delete shaderManager;
+
+    vertexBuffer.destroy();
+    texCoordBuffer.destroy();
+    opacityBuffer.destroy();
+    indexBuffer.destroy();
+    vao.destroy();
+
+    if (elementIndicesVBOId != 0) {
+        funcs.glDeleteBuffers(1, &elementIndicesVBOId);
+        elementIndicesVBOId = 0;
+    }
+}
+
+inline QColor qt_premultiplyColor(QColor c, GLfloat opacity)
+{
+    qreal alpha = c.alphaF() * opacity;
+    c.setAlphaF(alpha);
+    c.setRedF(c.redF() * alpha);
+    c.setGreenF(c.greenF() * alpha);
+    c.setBlueF(c.blueF() * alpha);
+    return c;
+}
+
+
+void QOpenGL2PaintEngineExPrivate::setBrush(const QBrush& brush)
+{
+    if (qbrush_fast_equals(currentBrush, brush))
+        return;
+
+    const Qt::BrushStyle newStyle = qbrush_style(brush);
+    Q_ASSERT(newStyle != Qt::NoBrush);
+
+    currentBrush = brush;
+    if (!currentBrushImage.isNull())
+        currentBrushImage = QImage();
+    brushUniformsDirty = true; // All brushes have at least one uniform
+
+    if (newStyle > Qt::SolidPattern)
+        brushTextureDirty = true;
+
+    if (currentBrush.style() == Qt::TexturePattern
+        && qHasPixmapTexture(brush) && brush.texture().isQBitmap())
+    {
+        shaderManager->setSrcPixelType(QOpenGLEngineShaderManager::TextureSrcWithPattern);
+    } else {
+        shaderManager->setSrcPixelType(newStyle);
+    }
+    shaderManager->optimiseForBrushTransform(currentBrush.transform().type());
+}
+
+
+void QOpenGL2PaintEngineExPrivate::useSimpleShader()
+{
+    shaderManager->useSimpleProgram();
+
+    if (matrixDirty)
+        updateMatrix();
+}
+
+/*
+    Single entry-point for activating, binding, and setting properties.
+
+    Allows keeping track of (caching) the latest texture unit and bound
+    texture in a central place, so that we can skip re-binding unless
+    needed.
+
+    \note Any code or Qt API that internally activates or binds will
+    not affect the cache used by this function, which means they will
+    lead to inconsisent state. QPainter::beginNativePainting() takes
+    care of resetting the cache, so for user–code this is fine, but
+    internally in the paint engine care must be taken to not call
+    functions that may activate or bind under our feet.
+*/
+template<typename T>
+void QOpenGL2PaintEngineExPrivate::updateTexture(GLenum textureUnit, const T &texture, GLenum wrapMode, GLenum filterMode, TextureUpdateMode updateMode)
+{
+    static const GLenum target = GL_TEXTURE_2D;
+
+    activateTextureUnit(textureUnit);
+
+    GLuint textureId = bindTexture(texture);
+
+    if (updateMode == UpdateIfNeeded && textureId == lastTextureUsed)
+        return;
+
+    lastTextureUsed = textureId;
+
+    funcs.glTexParameteri(target, GL_TEXTURE_WRAP_S, wrapMode);
+    funcs.glTexParameteri(target, GL_TEXTURE_WRAP_T, wrapMode);
+
+    funcs.glTexParameteri(target, GL_TEXTURE_MAG_FILTER, filterMode);
+    funcs.glTexParameteri(target, GL_TEXTURE_MIN_FILTER, filterMode);
+}
+
+void QOpenGL2PaintEngineExPrivate::activateTextureUnit(GLenum textureUnit)
+{
+    if (textureUnit != lastTextureUnitUsed) {
+        funcs.glActiveTexture(GL_TEXTURE0 + textureUnit);
+        lastTextureUnitUsed = textureUnit;
+
+        // We simplify things by keeping a single cached value of the last
+        // texture that was bound, instead of one per texture unit. This
+        // means that switching texture units could potentially mean we
+        // need a re-bind and corresponding parameter updates.
+        lastTextureUsed = GLuint(-1);
+    }
+}
+
+template<>
+GLuint QOpenGL2PaintEngineExPrivate::bindTexture(const GLuint &textureId)
+{
+    if (textureId != lastTextureUsed)
+        funcs.glBindTexture(GL_TEXTURE_2D, textureId);
+
+    return textureId;
+}
+
+template<>
+GLuint QOpenGL2PaintEngineExPrivate::bindTexture(const QImage &image)
+{
+    return QOpenGLTextureCache::cacheForContext(ctx)->bindTexture(ctx, image);
+}
+
+template<>
+GLuint QOpenGL2PaintEngineExPrivate::bindTexture(const QPixmap &pixmap)
+{
+    return QOpenGLTextureCache::cacheForContext(ctx)->bindTexture(ctx, pixmap);
+}
+
+template<>
+GLuint QOpenGL2PaintEngineExPrivate::bindTexture(const QGradient &gradient)
+{
+    // We apply global opacity in the fragment shaders, so we always pass 1.0
+    // for opacity to the cache.
+    GLuint textureId = QOpenGL2GradientCache::cacheForContext(ctx)->getBuffer(gradient, 1.0);
+
+    // QOpenGL2GradientCache::getBuffer() may bind and generate a new texture if it
+    // hasn't been cached yet, but will otherwise return an unbound texture id. To
+    // be sure that the texture is bound, we unfortunately have to bind again,
+    // which results in the initial generation of the texture doing two binds.
+    return bindTexture(textureId);
+}
+
+struct ImageWithBindOptions
+{
+    const QImage &image;
+    QOpenGLTextureUploader::BindOptions options;
+};
+
+template<>
+GLuint QOpenGL2PaintEngineExPrivate::bindTexture(const ImageWithBindOptions &imageWithOptions)
+{
+    return QOpenGLTextureCache::cacheForContext(ctx)->bindTexture(ctx, imageWithOptions.image, imageWithOptions.options);
+}
+
+inline static bool isPowerOfTwo(int x)
+{
+    // Assumption: x >= 1
+    return x == (x & -x);
+}
+
+void QOpenGL2PaintEngineExPrivate::updateBrushTexture()
+{
+    Q_Q(QOpenGL2PaintEngineEx);
+//     qDebug("QOpenGL2PaintEngineExPrivate::updateBrushTexture()");
+    Qt::BrushStyle style = currentBrush.style();
+
+    bool smoothPixmapTransform = q->state()->renderHints & QPainter::SmoothPixmapTransform;
+    GLenum filterMode = smoothPixmapTransform ? GL_LINEAR : GL_NEAREST;
+
+    if ( (style >= Qt::Dense1Pattern) && (style <= Qt::DiagCrossPattern) ) {
+        // Get the image data for the pattern
+        QImage textureImage = qt_imageForBrush(style, false);
+
+        updateTexture(QT_BRUSH_TEXTURE_UNIT, textureImage, GL_REPEAT, filterMode, ForceUpdate);
+    }
+    else if (style >= Qt::LinearGradientPattern && style <= Qt::ConicalGradientPattern) {
+        // Gradiant brush: All the gradiants use the same texture
+
+        const QGradient *gradient = currentBrush.gradient();
+
+        GLenum wrapMode = GL_CLAMP_TO_EDGE;
+        if (gradient->spread() == QGradient::RepeatSpread || gradient->type() == QGradient::ConicalGradient)
+            wrapMode = GL_REPEAT;
+        else if (gradient->spread() == QGradient::ReflectSpread)
+            wrapMode = GL_MIRRORED_REPEAT;
+
+        updateTexture(QT_BRUSH_TEXTURE_UNIT, *gradient, wrapMode, filterMode, ForceUpdate);
+    }
+    else if (style == Qt::TexturePattern) {
+        currentBrushImage = currentBrush.textureImage();
+
+        int max_texture_size = ctx->d_func()->maxTextureSize();
+        QSize newSize = currentBrushImage.size();
+        newSize = newSize.boundedTo(QSize(max_texture_size, max_texture_size));
+        if (!QOpenGLContext::currentContext()->functions()->hasOpenGLFeature(QOpenGLFunctions::NPOTTextureRepeat)) {
+            if (!isPowerOfTwo(newSize.width()) || !isPowerOfTwo(newSize.height())) {
+                newSize.setHeight(qNextPowerOfTwo(newSize.height() - 1));
+                newSize.setWidth(qNextPowerOfTwo(newSize.width() - 1));
+            }
+        }
+        if (currentBrushImage.size() != newSize)
+            currentBrushImage = currentBrushImage.scaled(newSize, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
+
+        GLuint wrapMode = GL_REPEAT;
+
+        updateTexture(QT_BRUSH_TEXTURE_UNIT, currentBrushImage, wrapMode, filterMode, ForceUpdate);
+    }
+    brushTextureDirty = false;
+}
+
+
+void QOpenGL2PaintEngineExPrivate::updateBrushUniforms()
+{
+//     qDebug("QOpenGL2PaintEngineExPrivate::updateBrushUniforms()");
+    Qt::BrushStyle style = currentBrush.style();
+
+    if (style == Qt::NoBrush)
+        return;
+
+    QTransform brushQTransform = currentBrush.transform();
+
+    if (style == Qt::SolidPattern) {
+        QColor col = qt_premultiplyColor(currentBrush.color(), (GLfloat)q->state()->opacity);
+        shaderManager->currentProgram()->setUniformValue(location(QOpenGLEngineShaderManager::FragmentColor), col);
+    }
+    else {
+        // All other brushes have a transform and thus need the translation point:
+        QPointF translationPoint;
+
+        if (style <= Qt::DiagCrossPattern) {
+            QColor col = qt_premultiplyColor(currentBrush.color(), (GLfloat)q->state()->opacity);
+
+            shaderManager->currentProgram()->setUniformValue(location(QOpenGLEngineShaderManager::PatternColor), col);
+
+            QVector2D halfViewportSize(width*0.5, height*0.5);
+            shaderManager->currentProgram()->setUniformValue(location(QOpenGLEngineShaderManager::HalfViewportSize), halfViewportSize);
+        }
+        else if (style == Qt::LinearGradientPattern) {
+            const QLinearGradient *g = static_cast<const QLinearGradient *>(currentBrush.gradient());
+
+            QPointF realStart = g->start();
+            QPointF realFinal = g->finalStop();
+            translationPoint = realStart;
+
+            QPointF l = realFinal - realStart;
+
+            QVector3D linearData(
+                l.x(),
+                l.y(),
+                1.0f / (l.x() * l.x() + l.y() * l.y())
+            );
+
+            shaderManager->currentProgram()->setUniformValue(location(QOpenGLEngineShaderManager::LinearData), linearData);
+
+            QVector2D halfViewportSize(width*0.5, height*0.5);
+            shaderManager->currentProgram()->setUniformValue(location(QOpenGLEngineShaderManager::HalfViewportSize), halfViewportSize);
+        }
+        else if (style == Qt::ConicalGradientPattern) {
+            const QConicalGradient *g = static_cast<const QConicalGradient *>(currentBrush.gradient());
+            translationPoint   = g->center();
+
+            GLfloat angle = -qDegreesToRadians(g->angle());
+
+            shaderManager->currentProgram()->setUniformValue(location(QOpenGLEngineShaderManager::Angle), angle);
+
+            QVector2D halfViewportSize(width*0.5, height*0.5);
+            shaderManager->currentProgram()->setUniformValue(location(QOpenGLEngineShaderManager::HalfViewportSize), halfViewportSize);
+        }
+        else if (style == Qt::RadialGradientPattern) {
+            const QRadialGradient *g = static_cast<const QRadialGradient *>(currentBrush.gradient());
+            QPointF realCenter = g->center();
+            QPointF realFocal  = g->focalPoint();
+            qreal   realRadius = g->centerRadius() - g->focalRadius();
+            translationPoint   = realFocal;
+
+            QPointF fmp = realCenter - realFocal;
+            shaderManager->currentProgram()->setUniformValue(location(QOpenGLEngineShaderManager::Fmp), fmp);
+
+            GLfloat fmp2_m_radius2 = -fmp.x() * fmp.x() - fmp.y() * fmp.y() + realRadius*realRadius;
+            shaderManager->currentProgram()->setUniformValue(location(QOpenGLEngineShaderManager::Fmp2MRadius2), fmp2_m_radius2);
+            shaderManager->currentProgram()->setUniformValue(location(QOpenGLEngineShaderManager::Inverse2Fmp2MRadius2),
+                                                             GLfloat(1.0 / (2.0*fmp2_m_radius2)));
+            shaderManager->currentProgram()->setUniformValue(location(QOpenGLEngineShaderManager::SqrFr),
+                                                             GLfloat(g->focalRadius() * g->focalRadius()));
+            shaderManager->currentProgram()->setUniformValue(location(QOpenGLEngineShaderManager::BRadius),
+                                                             GLfloat(2 * (g->centerRadius() - g->focalRadius()) * g->focalRadius()),
+                                                             g->focalRadius(),
+                                                             g->centerRadius() - g->focalRadius());
+
+            QVector2D halfViewportSize(width*0.5, height*0.5);
+            shaderManager->currentProgram()->setUniformValue(location(QOpenGLEngineShaderManager::HalfViewportSize), halfViewportSize);
+        }
+        else if (style == Qt::TexturePattern) {
+            const QPixmap& texPixmap = currentBrush.texture();
+
+            if (qHasPixmapTexture(currentBrush) && currentBrush.texture().isQBitmap()) {
+                QColor col = qt_premultiplyColor(currentBrush.color(), (GLfloat)q->state()->opacity);
+                shaderManager->currentProgram()->setUniformValue(location(QOpenGLEngineShaderManager::PatternColor), col);
+            }
+
+            QSizeF invertedTextureSize(1.0 / texPixmap.width(), 1.0 / texPixmap.height());
+            shaderManager->currentProgram()->setUniformValue(location(QOpenGLEngineShaderManager::InvertedTextureSize), invertedTextureSize);
+
+            QVector2D halfViewportSize(width*0.5, height*0.5);
+            shaderManager->currentProgram()->setUniformValue(location(QOpenGLEngineShaderManager::HalfViewportSize), halfViewportSize);
+        }
+        else
+            qWarning("QOpenGL2PaintEngineEx: Unimplemented fill style");
+
+        const QPointF &brushOrigin = q->state()->brushOrigin;
+        QTransform matrix = q->state()->matrix;
+        matrix.translate(brushOrigin.x(), brushOrigin.y());
+
+        QTransform translate(1, 0, 0, 1, -translationPoint.x(), -translationPoint.y());
+        qreal m22 = -1;
+        qreal dy = height;
+        if (device->paintFlipped()) {
+            m22 = 1;
+            dy = 0;
+        }
+        QTransform gl_to_qt(1, 0, 0, m22, 0, dy);
+        QTransform inv_matrix = gl_to_qt * (brushQTransform * matrix).inverted() * translate;
+
+        shaderManager->currentProgram()->setUniformValue(location(QOpenGLEngineShaderManager::BrushTransform), inv_matrix);
+        shaderManager->currentProgram()->setUniformValue(location(QOpenGLEngineShaderManager::BrushTexture), QT_BRUSH_TEXTURE_UNIT);
+    }
+    brushUniformsDirty = false;
+}
+
+
+// This assumes the shader manager has already setup the correct shader program
+void QOpenGL2PaintEngineExPrivate::updateMatrix()
+{
+//     qDebug("QOpenGL2PaintEngineExPrivate::updateMatrix()");
+
+    const QTransform& transform = q->state()->matrix;
+
+    // The projection matrix converts from Qt's coordinate system to GL's coordinate system
+    //    * GL's viewport is 2x2, Qt's is width x height
+    //    * GL has +y -> -y going from bottom -> top, Qt is the other way round
+    //    * GL has [0,0] in the center, Qt has it in the top-left
+    //
+    // This results in the Projection matrix below, which is multiplied by the painter's
+    // transformation matrix, as shown below:
+    //
+    //                Projection Matrix                      Painter Transform
+    // ------------------------------------------------   ------------------------
+    // | 2.0 / width  |      0.0      |     -1.0      |   |  m11  |  m21  |  dx  |
+    // |     0.0      | -2.0 / height |      1.0      | * |  m12  |  m22  |  dy  |
+    // |     0.0      |      0.0      |      1.0      |   |  m13  |  m23  |  m33 |
+    // ------------------------------------------------   ------------------------
+    //
+    // NOTE: The resultant matrix is also transposed, as GL expects column-major matracies
+
+    const GLfloat wfactor = 2.0f / width;
+    GLfloat hfactor = -2.0f / height;
+
+    GLfloat dx = transform.dx();
+    GLfloat dy = transform.dy();
+
+    if (device->paintFlipped()) {
+        hfactor *= -1;
+        dy -= height;
+    }
+
+    // Non-integer translates can have strange effects for some rendering operations such as
+    // anti-aliased text rendering. In such cases, we snap the translate to the pixel grid.
+    if (snapToPixelGrid && transform.type() == QTransform::TxTranslate) {
+        // 0.50 needs to rounded down to 0.0 for consistency with raster engine:
+        dx = std::ceil(dx - 0.5f);
+        dy = std::ceil(dy - 0.5f);
+    }
+    pmvMatrix[0][0] = (wfactor * transform.m11())  - transform.m13();
+    pmvMatrix[1][0] = (wfactor * transform.m21())  - transform.m23();
+    pmvMatrix[2][0] = (wfactor * dx) - transform.m33();
+    pmvMatrix[0][1] = (hfactor * transform.m12())  + transform.m13();
+    pmvMatrix[1][1] = (hfactor * transform.m22())  + transform.m23();
+    pmvMatrix[2][1] = (hfactor * dy) + transform.m33();
+    pmvMatrix[0][2] = transform.m13();
+    pmvMatrix[1][2] = transform.m23();
+    pmvMatrix[2][2] = transform.m33();
+
+    // 1/10000 == 0.0001, so we have good enough res to cover curves
+    // that span the entire widget...
+    inverseScale = qMax(1 / qMax( qMax(qAbs(transform.m11()), qAbs(transform.m22())),
+                                  qMax(qAbs(transform.m12()), qAbs(transform.m21())) ),
+                        qreal(0.0001));
+
+    matrixDirty = false;
+    matrixUniformDirty = true;
+
+    // Set the PMV matrix attribute. As we use an attributes rather than uniforms, we only
+    // need to do this once for every matrix change and persists across all shader programs.
+    funcs.glVertexAttrib3fv(QT_PMV_MATRIX_1_ATTR, pmvMatrix[0]);
+    funcs.glVertexAttrib3fv(QT_PMV_MATRIX_2_ATTR, pmvMatrix[1]);
+    funcs.glVertexAttrib3fv(QT_PMV_MATRIX_3_ATTR, pmvMatrix[2]);
+
+    dasher.setInvScale(inverseScale);
+    stroker.setInvScale(inverseScale);
+}
+
+
+void QOpenGL2PaintEngineExPrivate::updateCompositionMode()
+{
+    // NOTE: The entire paint engine works on pre-multiplied data - which is why some of these
+    //       composition modes look odd.
+//     qDebug() << "QOpenGL2PaintEngineExPrivate::updateCompositionMode() - Setting GL composition mode for " << q->state()->composition_mode;
+    if (ctx->functions()->hasOpenGLFeature(QOpenGLFunctions::BlendEquationAdvanced)) {
+       if (q->state()->composition_mode <= QPainter::CompositionMode_Plus) {
+           funcs.glDisable(GL_BLEND_ADVANCED_COHERENT_KHR);
+           funcs.glBlendEquation(GL_FUNC_ADD);
+       } else {
+           funcs.glEnable(GL_BLEND_ADVANCED_COHERENT_KHR);
+       }
+       shaderManager->setCompositionMode(q->state()->composition_mode);
+    } else {
+        if (q->state()->composition_mode > QPainter::CompositionMode_Plus) {
+            qWarning("Unsupported composition mode");
+            compositionModeDirty = false;
+            return;
+        }
+    }
+    switch(q->state()->composition_mode) {
+    case QPainter::CompositionMode_SourceOver:
+        funcs.glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
+        break;
+    case QPainter::CompositionMode_DestinationOver:
+        funcs.glBlendFunc(GL_ONE_MINUS_DST_ALPHA, GL_ONE);
+        break;
+    case QPainter::CompositionMode_Clear:
+        funcs.glBlendFunc(GL_ZERO, GL_ZERO);
+        break;
+    case QPainter::CompositionMode_Source:
+        funcs.glBlendFunc(GL_ONE, GL_ZERO);
+        break;
+    case QPainter::CompositionMode_Destination:
+        funcs.glBlendFunc(GL_ZERO, GL_ONE);
+        break;
+    case QPainter::CompositionMode_SourceIn:
+        funcs.glBlendFunc(GL_DST_ALPHA, GL_ZERO);
+        break;
+    case QPainter::CompositionMode_DestinationIn:
+        funcs.glBlendFunc(GL_ZERO, GL_SRC_ALPHA);
+        break;
+    case QPainter::CompositionMode_SourceOut:
+        funcs.glBlendFunc(GL_ONE_MINUS_DST_ALPHA, GL_ZERO);
+        break;
+    case QPainter::CompositionMode_DestinationOut:
+        funcs.glBlendFunc(GL_ZERO, GL_ONE_MINUS_SRC_ALPHA);
+        break;
+    case QPainter::CompositionMode_SourceAtop:
+        funcs.glBlendFunc(GL_DST_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+        break;
+    case QPainter::CompositionMode_DestinationAtop:
+        funcs.glBlendFunc(GL_ONE_MINUS_DST_ALPHA, GL_SRC_ALPHA);
+        break;
+    case QPainter::CompositionMode_Xor:
+        funcs.glBlendFunc(GL_ONE_MINUS_DST_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+        break;
+    case QPainter::CompositionMode_Plus:
+        funcs.glBlendFunc(GL_ONE, GL_ONE);
+        break;
+    case QPainter::CompositionMode_Multiply:
+        funcs.glBlendEquation(GL_MULTIPLY_KHR);
+        break;
+    case QPainter::CompositionMode_Screen:
+        funcs.glBlendEquation(GL_SCREEN_KHR);
+        break;
+    case QPainter::CompositionMode_Overlay:
+        funcs.glBlendEquation(GL_OVERLAY_KHR);
+        break;
+    case QPainter::CompositionMode_Darken:
+        funcs.glBlendEquation(GL_DARKEN_KHR);
+        break;
+    case QPainter::CompositionMode_Lighten:
+        funcs.glBlendEquation(GL_LIGHTEN_KHR);
+        break;
+    case QPainter::CompositionMode_ColorDodge:
+        funcs.glBlendEquation(GL_COLORDODGE_KHR);
+        break;
+    case QPainter::CompositionMode_ColorBurn:
+        funcs.glBlendEquation(GL_COLORBURN_KHR);
+        break;
+    case QPainter::CompositionMode_HardLight:
+        funcs.glBlendEquation(GL_HARDLIGHT_KHR);
+        break;
+    case QPainter::CompositionMode_SoftLight:
+        funcs.glBlendEquation(GL_SOFTLIGHT_KHR);
+        break;
+    case QPainter::CompositionMode_Difference:
+        funcs.glBlendEquation(GL_DIFFERENCE_KHR);
+        break;
+    case QPainter::CompositionMode_Exclusion:
+        funcs.glBlendEquation(GL_EXCLUSION_KHR);
+        break;
+    default:
+        qWarning("Unsupported composition mode");
+        break;
+    }
+
+    compositionModeDirty = false;
+}
+
+static inline void setCoords(GLfloat *coords, const QOpenGLRect &rect)
+{
+    coords[0] = rect.left;
+    coords[1] = rect.top;
+    coords[2] = rect.right;
+    coords[3] = rect.top;
+    coords[4] = rect.right;
+    coords[5] = rect.bottom;
+    coords[6] = rect.left;
+    coords[7] = rect.bottom;
+}
+
+void QOpenGL2PaintEngineExPrivate::drawTexture(const QOpenGLRect& dest, const QOpenGLRect& src, const QSize &textureSize, bool opaque, bool pattern)
+{
+    // Setup for texture drawing
+    currentBrush = noBrush;
+
+    if (snapToPixelGrid) {
+        snapToPixelGrid = false;
+        matrixDirty = true;
+    }
+
+    if (prepareForDraw(opaque))
+        shaderManager->currentProgram()->setUniformValue(location(QOpenGLEngineShaderManager::ImageTexture), QT_IMAGE_TEXTURE_UNIT);
+
+    if (pattern) {
+        QColor col = qt_premultiplyColor(q->state()->pen.color(), (GLfloat)q->state()->opacity);
+        shaderManager->currentProgram()->setUniformValue(location(QOpenGLEngineShaderManager::PatternColor), col);
+    }
+
+    GLfloat dx = 1.0 / textureSize.width();
+    GLfloat dy = 1.0 / textureSize.height();
+
+    QOpenGLRect srcTextureRect(src.left*dx, src.top*dy, src.right*dx, src.bottom*dy);
+
+    setCoords(staticVertexCoordinateArray, dest);
+    setCoords(staticTextureCoordinateArray, srcTextureRect);
+
+    setVertexAttribArrayEnabled(QT_VERTEX_COORDS_ATTR, true);
+    setVertexAttribArrayEnabled(QT_TEXTURE_COORDS_ATTR, true);
+
+    uploadData(QT_VERTEX_COORDS_ATTR, staticVertexCoordinateArray, 8);
+    uploadData(QT_TEXTURE_COORDS_ATTR, staticTextureCoordinateArray, 8);
+
+    funcs.glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
+}
+
+void QOpenGL2PaintEngineEx::beginNativePainting()
+{
+    Q_D(QOpenGL2PaintEngineEx);
+    ensureActive();
+    d->transferMode(BrushDrawingMode);
+
+    d->nativePaintingActive = true;
+
+    d->funcs.glUseProgram(0);
+
+    // Disable all the vertex attribute arrays:
+    for (int i = 0; i < QT_GL_VERTEX_ARRAY_TRACKED_COUNT; ++i)
+        d->funcs.glDisableVertexAttribArray(i);
+
+#if !defined(QT_OPENGL_ES_2) && !defined(QT_OPENGL_DYNAMIC)
+    Q_ASSERT(QOpenGLContext::currentContext());
+    const QOpenGLContext *ctx = d->ctx;
+    const QSurfaceFormat &fmt = d->device->context()->format();
+    if (fmt.majorVersion() < 3 || (fmt.majorVersion() == 3 && fmt.minorVersion() < 1)
+        || (fmt.majorVersion() == 3 && fmt.minorVersion() == 1 && ctx->hasExtension(QByteArrayLiteral("GL_ARB_compatibility")))
+        || fmt.profile() == QSurfaceFormat::CompatibilityProfile)
+    {
+        // be nice to people who mix OpenGL 1.x code with QPainter commands
+        // by setting modelview and projection matrices to mirror the GL 1
+        // paint engine
+        const QTransform& mtx = state()->matrix;
+
+        float mv_matrix[4][4] =
+            {
+                { float(mtx.m11()), float(mtx.m12()),     0, float(mtx.m13()) },
+                { float(mtx.m21()), float(mtx.m22()),     0, float(mtx.m23()) },
+                {                0,                0,     1,                0 },
+                {  float(mtx.dx()),  float(mtx.dy()),     0, float(mtx.m33()) }
+            };
+
+        const QSize sz = d->device->size();
+
+        glMatrixMode(GL_PROJECTION);
+        glLoadIdentity();
+        glOrtho(0, sz.width(), sz.height(), 0, -999999, 999999);
+
+        glMatrixMode(GL_MODELVIEW);
+        glLoadMatrixf(&mv_matrix[0][0]);
+    }
+#endif // QT_OPENGL_ES_2
+
+    d->resetGLState();
+
+    // We don't know what texture units and textures the native painting
+    // will activate and bind, so we can't assume anything when we return
+    // from the native painting.
+    d->lastTextureUnitUsed = QT_UNKNOWN_TEXTURE_UNIT;
+    d->lastTextureUsed = GLuint(-1);
+
+    d->dirtyStencilRegion = QRect(0, 0, d->width, d->height);
+
+    d->shaderManager->setDirty();
+
+    d->needsSync = true;
+}
+
+void QOpenGL2PaintEngineExPrivate::resetGLState()
+{
+    activateTextureUnit(QT_DEFAULT_TEXTURE_UNIT);
+
+    funcs.glDisable(GL_BLEND);
+    funcs.glDisable(GL_STENCIL_TEST);
+    funcs.glDisable(GL_DEPTH_TEST);
+    funcs.glDisable(GL_SCISSOR_TEST);
+    funcs.glDepthMask(true);
+    funcs.glDepthFunc(GL_LESS);
+    funcs.glClearDepthf(1);
+    funcs.glStencilMask(0xff);
+    funcs.glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
+    funcs.glStencilFunc(GL_ALWAYS, 0, 0xff);
+    setVertexAttribArrayEnabled(QT_TEXTURE_COORDS_ATTR, false);
+    setVertexAttribArrayEnabled(QT_VERTEX_COORDS_ATTR, false);
+    setVertexAttribArrayEnabled(QT_OPACITY_ATTR, false);
+    if (!QOpenGLContext::currentContext()->isOpenGLES()) {
+        // gl_Color, corresponding to vertex attribute 3, may have been changed
+        float color[] = { 1.0f, 1.0f, 1.0f, 1.0f };
+        funcs.glVertexAttrib4fv(3, color);
+    }
+    if (vao.isCreated()) {
+        vao.release();
+        funcs.glBindBuffer(GL_ARRAY_BUFFER, 0);
+        funcs.glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+    }
+}
+
+void QOpenGL2PaintEngineEx::endNativePainting()
+{
+    Q_D(QOpenGL2PaintEngineEx);
+    d->needsSync = true;
+    d->nativePaintingActive = false;
+}
+
+void QOpenGL2PaintEngineEx::invalidateState()
+{
+    Q_D(QOpenGL2PaintEngineEx);
+    d->needsSync = true;
+}
+
+bool QOpenGL2PaintEngineEx::isNativePaintingActive() const {
+    Q_D(const QOpenGL2PaintEngineEx);
+    return d->nativePaintingActive;
+}
+
+void QOpenGL2PaintEngineExPrivate::transferMode(EngineMode newMode)
+{
+    if (newMode == mode)
+        return;
+
+    if (newMode == TextDrawingMode) {
+        shaderManager->setHasComplexGeometry(true);
+    } else {
+        shaderManager->setHasComplexGeometry(false);
+    }
+
+    if (newMode == ImageDrawingMode) {
+        uploadData(QT_VERTEX_COORDS_ATTR, staticVertexCoordinateArray, 8);
+        uploadData(QT_TEXTURE_COORDS_ATTR, staticTextureCoordinateArray, 8);
+    }
+
+    if (newMode == ImageArrayDrawingMode || newMode == ImageOpacityArrayDrawingMode) {
+        uploadData(QT_VERTEX_COORDS_ATTR, (GLfloat*)vertexCoordinateArray.data(), vertexCoordinateArray.vertexCount() * 2);
+        uploadData(QT_TEXTURE_COORDS_ATTR, (GLfloat*)textureCoordinateArray.data(), textureCoordinateArray.vertexCount() * 2);
+
+        if (newMode == ImageOpacityArrayDrawingMode)
+            uploadData(QT_OPACITY_ATTR, (GLfloat*)opacityArray.data(), opacityArray.size());
+    }
+
+    // This needs to change when we implement high-quality anti-aliasing...
+    if (newMode != TextDrawingMode)
+        shaderManager->setMaskType(QOpenGLEngineShaderManager::NoMask);
+
+    mode = newMode;
+}
+
+struct QOpenGL2PEVectorPathCache
+{
+#ifdef QT_OPENGL_CACHE_AS_VBOS
+    GLuint vbo;
+    GLuint ibo;
+#else
+    float *vertices;
+    void *indices;
+#endif
+    int vertexCount;
+    int indexCount;
+    GLenum primitiveType;
+    qreal iscale;
+    QVertexIndexVector::Type indexType;
+};
+
+void QOpenGL2PaintEngineExPrivate::cleanupVectorPath(QPaintEngineEx *engine, void *data)
+{
+    QOpenGL2PEVectorPathCache *c = (QOpenGL2PEVectorPathCache *) data;
+#ifdef QT_OPENGL_CACHE_AS_VBOS
+    Q_ASSERT(engine->type() == QPaintEngine::OpenGL2);
+    static_cast<QOpenGL2PaintEngineEx *>(engine)->d_func()->unusedVBOSToClean << c->vbo;
+    if (c->ibo)
+        d->unusedIBOSToClean << c->ibo;
+#else
+    Q_UNUSED(engine);
+    free(c->vertices);
+    free(c->indices);
+#endif
+    delete c;
+}
+
+// Assumes everything is configured for the brush you want to use
+void QOpenGL2PaintEngineExPrivate::fill(const QVectorPath& path)
+{
+    transferMode(BrushDrawingMode);
+
+    if (snapToPixelGrid) {
+        snapToPixelGrid = false;
+        matrixDirty = true;
+    }
+
+    // Might need to call updateMatrix to re-calculate inverseScale
+    if (matrixDirty)
+        updateMatrix();
+
+    const bool supportsElementIndexUint = funcs.hasOpenGLExtension(QOpenGLExtensions::ElementIndexUint);
+
+    const QPointF* const points = reinterpret_cast<const QPointF*>(path.points());
+
+    // Check to see if there's any hints
+    if (path.shape() == QVectorPath::RectangleHint) {
+        QOpenGLRect rect(points[0].x(), points[0].y(), points[2].x(), points[2].y());
+        prepareForDraw(currentBrush.isOpaque());
+        composite(rect);
+    } else if (path.isConvex()) {
+
+        if (path.isCacheable()) {
+            QVectorPath::CacheEntry *data = path.lookupCacheData(q);
+            QOpenGL2PEVectorPathCache *cache;
+
+            bool updateCache = false;
+
+            if (data) {
+                cache = (QOpenGL2PEVectorPathCache *) data->data;
+                // Check if scale factor is exceeded and regenerate if so...
+                qreal scaleFactor = cache->iscale / inverseScale;
+                if (scaleFactor < 0.5 || scaleFactor > 2.0) {
+#ifdef QT_OPENGL_CACHE_AS_VBOS
+                    glDeleteBuffers(1, &cache->vbo);
+                    cache->vbo = 0;
+                    Q_ASSERT(cache->ibo == 0);
+#else
+                    free(cache->vertices);
+                    Q_ASSERT(cache->indices == nullptr);
+#endif
+                    updateCache = true;
+                }
+            } else {
+                cache = new QOpenGL2PEVectorPathCache;
+                data = const_cast<QVectorPath &>(path).addCacheData(q, cache, cleanupVectorPath);
+                updateCache = true;
+            }
+
+            // Flatten the path at the current scale factor and fill it into the cache struct.
+            if (updateCache) {
+                vertexCoordinateArray.clear();
+                vertexCoordinateArray.addPath(path, inverseScale, false);
+                int vertexCount = vertexCoordinateArray.vertexCount();
+                int floatSizeInBytes = vertexCount * 2 * sizeof(float);
+                cache->vertexCount = vertexCount;
+                cache->indexCount = 0;
+                cache->primitiveType = GL_TRIANGLE_FAN;
+                cache->iscale = inverseScale;
+#ifdef QT_OPENGL_CACHE_AS_VBOS
+                funcs.glGenBuffers(1, &cache->vbo);
+                funcs.glBindBuffer(GL_ARRAY_BUFFER, cache->vbo);
+                funcs.glBufferData(GL_ARRAY_BUFFER, floatSizeInBytes, vertexCoordinateArray.data(), GL_STATIC_DRAW);
+                cache->ibo = 0;
+#else
+                cache->vertices = (float *) malloc(floatSizeInBytes);
+                memcpy(cache->vertices, vertexCoordinateArray.data(), floatSizeInBytes);
+                cache->indices = nullptr;
+#endif
+            }
+
+            prepareForDraw(currentBrush.isOpaque());
+#ifdef QT_OPENGL_CACHE_AS_VBOS
+            funcs.glBindBuffer(GL_ARRAY_BUFFER, cache->vbo);
+            uploadData(QT_VERTEX_COORD_ATTR, 0, cache->vertexCount);
+            setVertexAttributePointer(QT_VERTEX_COORDS_ATTR, 0);
+#else
+            uploadData(QT_VERTEX_COORDS_ATTR, cache->vertices, cache->vertexCount * 2);
+#endif
+            funcs.glDrawArrays(cache->primitiveType, 0, cache->vertexCount);
+
+        } else {
+      //        printf(" - Marking path as cachable...\n");
+            // Tag it for later so that if the same path is drawn twice, it is assumed to be static and thus cachable
+            path.makeCacheable();
+            vertexCoordinateArray.clear();
+            vertexCoordinateArray.addPath(path, inverseScale, false);
+            prepareForDraw(currentBrush.isOpaque());
+            drawVertexArrays(vertexCoordinateArray, GL_TRIANGLE_FAN);
+        }
+
+    } else {
+        bool useCache = path.isCacheable();
+        if (useCache) {
+            QRectF bbox = path.controlPointRect();
+            // If the path doesn't fit within these limits, it is possible that the triangulation will fail.
+            useCache &= (bbox.left() > -0x8000 * inverseScale)
+                     && (bbox.right() < 0x8000 * inverseScale)
+                     && (bbox.top() > -0x8000 * inverseScale)
+                     && (bbox.bottom() < 0x8000 * inverseScale);
+        }
+
+        if (useCache) {
+            QVectorPath::CacheEntry *data = path.lookupCacheData(q);
+            QOpenGL2PEVectorPathCache *cache;
+
+            bool updateCache = false;
+
+            if (data) {
+                cache = (QOpenGL2PEVectorPathCache *) data->data;
+                // Check if scale factor is exceeded and regenerate if so...
+                qreal scaleFactor = cache->iscale / inverseScale;
+                if (scaleFactor < 0.5 || scaleFactor > 2.0) {
+#ifdef QT_OPENGL_CACHE_AS_VBOS
+                    glDeleteBuffers(1, &cache->vbo);
+                    glDeleteBuffers(1, &cache->ibo);
+#else
+                    free(cache->vertices);
+                    free(cache->indices);
+#endif
+                    updateCache = true;
+                }
+            } else {
+                cache = new QOpenGL2PEVectorPathCache;
+                data = const_cast<QVectorPath &>(path).addCacheData(q, cache, cleanupVectorPath);
+                updateCache = true;
+            }
+
+            // Flatten the path at the current scale factor and fill it into the cache struct.
+            if (updateCache) {
+                QTriangleSet polys = qTriangulate(path, QTransform().scale(1 / inverseScale, 1 / inverseScale), 1, supportsElementIndexUint);
+                cache->vertexCount = polys.vertices.size() / 2;
+                cache->indexCount = polys.indices.size();
+                cache->primitiveType = GL_TRIANGLES;
+                cache->iscale = inverseScale;
+                cache->indexType = polys.indices.type();
+#ifdef QT_OPENGL_CACHE_AS_VBOS
+                funcs.glGenBuffers(1, &cache->vbo);
+                funcs.glGenBuffers(1, &cache->ibo);
+                funcs.glBindBuffer(GL_ARRAY_BUFFER, cache->vbo);
+                funcs.glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, cache->ibo);
+
+                if (polys.indices.type() == QVertexIndexVector::UnsignedInt)
+                    funcs.glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(quint32) * polys.indices.size(), polys.indices.data(), GL_STATIC_DRAW);
+                else
+                    funcs.glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(quint16) * polys.indices.size(), polys.indices.data(), GL_STATIC_DRAW);
+
+                QVarLengthArray<float> vertices(polys.vertices.size());
+                for (int i = 0; i < polys.vertices.size(); ++i)
+                    vertices[i] = float(inverseScale * polys.vertices.at(i));
+                funcs.glBufferData(GL_ARRAY_BUFFER, sizeof(float) * vertices.size(), vertices.data(), GL_STATIC_DRAW);
+#else
+                cache->vertices = (float *) malloc(sizeof(float) * polys.vertices.size());
+                if (polys.indices.type() == QVertexIndexVector::UnsignedInt) {
+                    cache->indices = (quint32 *) malloc(sizeof(quint32) * polys.indices.size());
+                    memcpy(cache->indices, polys.indices.data(), sizeof(quint32) * polys.indices.size());
+                } else {
+                    cache->indices = (quint16 *) malloc(sizeof(quint16) * polys.indices.size());
+                    memcpy(cache->indices, polys.indices.data(), sizeof(quint16) * polys.indices.size());
+                }
+                for (int i = 0; i < polys.vertices.size(); ++i)
+                    cache->vertices[i] = float(inverseScale * polys.vertices.at(i));
+#endif
+            }
+
+            prepareForDraw(currentBrush.isOpaque());
+#ifdef QT_OPENGL_CACHE_AS_VBOS
+            funcs.glBindBuffer(GL_ARRAY_BUFFER, cache->vbo);
+            funcs.glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, cache->ibo);
+            uploadData(QT_VERTEX_COORDS_ATTR, 0, cache->vertexCount);
+            setVertexAttributePointer(QT_VERTEX_COORDS_ATTR, 0);
+            if (cache->indexType == QVertexIndexVector::UnsignedInt)
+                funcs.glDrawElements(cache->primitiveType, cache->indexCount, GL_UNSIGNED_INT, 0);
+            else
+                funcs.glDrawElements(cache->primitiveType, cache->indexCount, GL_UNSIGNED_SHORT, 0);
+            funcs.glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+            funcs.glBindBuffer(GL_ARRAY_BUFFER, 0);
+#else
+            uploadData(QT_VERTEX_COORDS_ATTR, cache->vertices, cache->vertexCount * 2);
+            const GLenum indexValueType = cache->indexType == QVertexIndexVector::UnsignedInt ? GL_UNSIGNED_INT : GL_UNSIGNED_SHORT;
+            const bool useIndexVbo = uploadIndexData(cache->indices, indexValueType, cache->indexCount);
+            funcs.glDrawElements(cache->primitiveType, cache->indexCount, indexValueType, useIndexVbo ? nullptr : cache->indices);
+#endif
+
+        } else {
+      //        printf(" - Marking path as cachable...\n");
+            // Tag it for later so that if the same path is drawn twice, it is assumed to be static and thus cachable
+            path.makeCacheable();
+
+            if (device->context()->format().stencilBufferSize() <= 0) {
+                // If there is no stencil buffer, triangulate the path instead.
+
+                QRectF bbox = path.controlPointRect();
+                // If the path doesn't fit within these limits, it is possible that the triangulation will fail.
+                bool withinLimits = (bbox.left() > -0x8000 * inverseScale)
+                                  && (bbox.right() < 0x8000 * inverseScale)
+                                  && (bbox.top() > -0x8000 * inverseScale)
+                                  && (bbox.bottom() < 0x8000 * inverseScale);
+                if (withinLimits) {
+                    QTriangleSet polys = qTriangulate(path, QTransform().scale(1 / inverseScale, 1 / inverseScale), 1, supportsElementIndexUint);
+
+                    QVarLengthArray<float> vertices(polys.vertices.size());
+                    for (int i = 0; i < polys.vertices.size(); ++i)
+                        vertices[i] = float(inverseScale * polys.vertices.at(i));
+
+                    prepareForDraw(currentBrush.isOpaque());
+                    uploadData(QT_VERTEX_COORDS_ATTR, vertices.constData(), vertices.size());
+                    const GLenum indexValueType = funcs.hasOpenGLExtension(QOpenGLExtensions::ElementIndexUint) ? GL_UNSIGNED_INT : GL_UNSIGNED_SHORT;
+                    const bool useIndexVbo = uploadIndexData(polys.indices.data(), indexValueType, polys.indices.size());
+                    funcs.glDrawElements(GL_TRIANGLES, polys.indices.size(), indexValueType, useIndexVbo ? nullptr : polys.indices.data());
+                } else {
+                    // We can't handle big, concave painter paths with OpenGL without stencil buffer.
+                    qWarning("Painter path exceeds +/-32767 pixels.");
+                }
+                return;
+            }
+
+            // The path is too complicated & needs the stencil technique
+            vertexCoordinateArray.clear();
+            vertexCoordinateArray.addPath(path, inverseScale, false);
+
+            fillStencilWithVertexArray(vertexCoordinateArray, path.hasWindingFill());
+
+            funcs.glStencilMask(0xff);
+            funcs.glStencilOp(GL_KEEP, GL_REPLACE, GL_REPLACE);
+
+            if (q->state()->clipTestEnabled) {
+                // Pass when high bit is set, replace stencil value with current clip
+                funcs.glStencilFunc(GL_NOTEQUAL, q->state()->currentClip, GL_STENCIL_HIGH_BIT);
+            } else if (path.hasWindingFill()) {
+                // Pass when any bit is set, replace stencil value with 0
+                funcs.glStencilFunc(GL_NOTEQUAL, 0, 0xff);
+            } else {
+                // Pass when high bit is set, replace stencil value with 0
+                funcs.glStencilFunc(GL_NOTEQUAL, 0, GL_STENCIL_HIGH_BIT);
+            }
+            prepareForDraw(currentBrush.isOpaque());
+
+            // Stencil the brush onto the dest buffer
+            composite(vertexCoordinateArray.boundingRect());
+            funcs.glStencilMask(0);
+            updateClipScissorTest();
+        }
+    }
+}
+
+
+void QOpenGL2PaintEngineExPrivate::fillStencilWithVertexArray(const float *data,
+                                                          int count,
+                                                          int *stops,
+                                                          int stopCount,
+                                                          const QOpenGLRect &bounds,
+                                                          StencilFillMode mode)
+{
+    Q_ASSERT(count || stops);
+
+//     qDebug("QOpenGL2PaintEngineExPrivate::fillStencilWithVertexArray()");
+    funcs.glStencilMask(0xff); // Enable stencil writes
+
+    if (dirtyStencilRegion.intersects(currentScissorBounds)) {
+        const QRegion clearRegion = dirtyStencilRegion.intersected(currentScissorBounds);
+        funcs.glClearStencil(0); // Clear to zero
+        for (const QRect &rect : clearRegion) {
+#ifndef QT_GL_NO_SCISSOR_TEST
+            setScissor(rect);
+#endif
+            funcs.glClear(GL_STENCIL_BUFFER_BIT);
+        }
+
+        dirtyStencilRegion -= currentScissorBounds;
+
+#ifndef QT_GL_NO_SCISSOR_TEST
+        updateClipScissorTest();
+#endif
+    }
+
+    funcs.glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE); // Disable color writes
+    useSimpleShader();
+    funcs.glEnable(GL_STENCIL_TEST); // For some reason, this has to happen _after_ the simple shader is use()'d
+
+    if (mode == WindingFillMode) {
+        Q_ASSERT(stops && !count);
+        if (q->state()->clipTestEnabled) {
+            // Flatten clip values higher than current clip, and set high bit to match current clip
+            funcs.glStencilFunc(GL_LEQUAL, GL_STENCIL_HIGH_BIT | q->state()->currentClip, ~GL_STENCIL_HIGH_BIT);
+            funcs.glStencilOp(GL_KEEP, GL_REPLACE, GL_REPLACE);
+            composite(bounds);
+
+            funcs.glStencilFunc(GL_EQUAL, GL_STENCIL_HIGH_BIT, GL_STENCIL_HIGH_BIT);
+        } else if (!stencilClean) {
+            // Clear stencil buffer within bounding rect
+            funcs.glStencilFunc(GL_ALWAYS, 0, 0xff);
+            funcs.glStencilOp(GL_ZERO, GL_ZERO, GL_ZERO);
+            composite(bounds);
+        }
+
+        // Inc. for front-facing triangle
+        funcs.glStencilOpSeparate(GL_FRONT, GL_KEEP, GL_INCR_WRAP, GL_INCR_WRAP);
+        // Dec. for back-facing "holes"
+        funcs.glStencilOpSeparate(GL_BACK, GL_KEEP, GL_DECR_WRAP, GL_DECR_WRAP);
+        funcs.glStencilMask(~GL_STENCIL_HIGH_BIT);
+        drawVertexArrays(data, stops, stopCount, GL_TRIANGLE_FAN);
+
+        if (q->state()->clipTestEnabled) {
+            // Clear high bit of stencil outside of path
+            funcs.glStencilFunc(GL_EQUAL, q->state()->currentClip, ~GL_STENCIL_HIGH_BIT);
+            funcs.glStencilOp(GL_KEEP, GL_REPLACE, GL_REPLACE);
+            funcs.glStencilMask(GL_STENCIL_HIGH_BIT);
+            composite(bounds);
+        }
+    } else if (mode == OddEvenFillMode) {
+        funcs.glStencilMask(GL_STENCIL_HIGH_BIT);
+        funcs.glStencilOp(GL_KEEP, GL_KEEP, GL_INVERT); // Simply invert the stencil bit
+        drawVertexArrays(data, stops, stopCount, GL_TRIANGLE_FAN);
+
+    } else { // TriStripStrokeFillMode
+        Q_ASSERT(count && !stops); // tristrips generated directly, so no vertexArray or stops
+        funcs.glStencilMask(GL_STENCIL_HIGH_BIT);
+#if 0
+        funcs.glStencilOp(GL_KEEP, GL_KEEP, GL_INVERT); // Simply invert the stencil bit
+        setVertexAttributePointer(QT_VERTEX_COORDS_ATTR, data);
+        funcs.glDrawArrays(GL_TRIANGLE_STRIP, 0, count);
+#else
+
+        funcs.glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
+        if (q->state()->clipTestEnabled) {
+            funcs.glStencilFunc(GL_LEQUAL, q->state()->currentClip | GL_STENCIL_HIGH_BIT,
+                                ~GL_STENCIL_HIGH_BIT);
+        } else {
+            funcs.glStencilFunc(GL_ALWAYS, GL_STENCIL_HIGH_BIT, 0xff);
+        }
+
+        uploadData(QT_VERTEX_COORDS_ATTR, data, count * 2);
+        funcs.glDrawArrays(GL_TRIANGLE_STRIP, 0, count);
+#endif
+    }
+
+    // Enable color writes & disable stencil writes
+    funcs.glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
+}
+
+/*
+    If the maximum value in the stencil buffer is GL_STENCIL_HIGH_BIT - 1,
+    restore the stencil buffer to a pristine state.  The current clip region
+    is set to 1, and the rest to 0.
+*/
+void QOpenGL2PaintEngineExPrivate::resetClipIfNeeded()
+{
+    if (maxClip != (GL_STENCIL_HIGH_BIT - 1))
+        return;
+
+    Q_Q(QOpenGL2PaintEngineEx);
+
+    useSimpleShader();
+    funcs.glEnable(GL_STENCIL_TEST);
+    funcs.glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
+
+    QRectF bounds = q->state()->matrix.inverted().mapRect(QRectF(0, 0, width, height));
+    QOpenGLRect rect(bounds.left(), bounds.top(), bounds.right(), bounds.bottom());
+
+    // Set high bit on clip region
+    funcs.glStencilFunc(GL_LEQUAL, q->state()->currentClip, 0xff);
+    funcs.glStencilOp(GL_KEEP, GL_INVERT, GL_INVERT);
+    funcs.glStencilMask(GL_STENCIL_HIGH_BIT);
+    composite(rect);
+
+    // Reset clipping to 1 and everything else to zero
+    funcs.glStencilFunc(GL_NOTEQUAL, 0x01, GL_STENCIL_HIGH_BIT);
+    funcs.glStencilOp(GL_ZERO, GL_REPLACE, GL_REPLACE);
+    funcs.glStencilMask(0xff);
+    composite(rect);
+
+    q->state()->currentClip = 1;
+    q->state()->canRestoreClip = false;
+
+    maxClip = 1;
+
+    funcs.glStencilMask(0x0);
+    funcs.glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
+}
+
+bool QOpenGL2PaintEngineExPrivate::prepareForCachedGlyphDraw(const QFontEngineGlyphCache &cache)
+{
+    Q_Q(QOpenGL2PaintEngineEx);
+
+    Q_ASSERT(cache.transform().type() <= QTransform::TxScale);
+
+    QTransform &transform = q->state()->matrix;
+    transform.scale(1.0 / cache.transform().m11(), 1.0 / cache.transform().m22());
+    bool ret = prepareForDraw(false);
+    transform.scale(cache.transform().m11(), cache.transform().m22());
+
+    return ret;
+}
+
+bool QOpenGL2PaintEngineExPrivate::prepareForDraw(bool srcPixelsAreOpaque)
+{
+    if (brushTextureDirty && (mode == TextDrawingMode || mode == BrushDrawingMode))
+        updateBrushTexture();
+
+    if (compositionModeDirty)
+        updateCompositionMode();
+
+    if (matrixDirty)
+        updateMatrix();
+
+    const bool stateHasOpacity = q->state()->opacity < 0.99f;
+    if (q->state()->composition_mode == QPainter::CompositionMode_Source
+        || (q->state()->composition_mode == QPainter::CompositionMode_SourceOver
+            && srcPixelsAreOpaque && !stateHasOpacity))
+    {
+        funcs.glDisable(GL_BLEND);
+    } else {
+        funcs.glEnable(GL_BLEND);
+    }
+
+    QOpenGLEngineShaderManager::OpacityMode opacityMode;
+    if (mode == ImageOpacityArrayDrawingMode) {
+        opacityMode = QOpenGLEngineShaderManager::AttributeOpacity;
+    } else {
+        opacityMode = stateHasOpacity ? QOpenGLEngineShaderManager::UniformOpacity
+                                      : QOpenGLEngineShaderManager::NoOpacity;
+        if (stateHasOpacity && (mode != ImageDrawingMode && mode != ImageArrayDrawingMode)) {
+            // Using a brush
+            bool brushIsPattern = (currentBrush.style() >= Qt::Dense1Pattern) &&
+                                  (currentBrush.style() <= Qt::DiagCrossPattern);
+
+            if ((currentBrush.style() == Qt::SolidPattern) || brushIsPattern)
+                opacityMode = QOpenGLEngineShaderManager::NoOpacity; // Global opacity handled by srcPixel shader
+        }
+    }
+    shaderManager->setOpacityMode(opacityMode);
+
+    bool changed = shaderManager->useCorrectShaderProg();
+    // If the shader program needs changing, we change it and mark all uniforms as dirty
+    if (changed) {
+        // The shader program has changed so mark all uniforms as dirty:
+        brushUniformsDirty = true;
+        opacityUniformDirty = true;
+        matrixUniformDirty = true;
+    }
+
+    if (brushUniformsDirty && (mode == TextDrawingMode || mode == BrushDrawingMode))
+        updateBrushUniforms();
+
+    if (opacityMode == QOpenGLEngineShaderManager::UniformOpacity && opacityUniformDirty) {
+        shaderManager->currentProgram()->setUniformValue(location(QOpenGLEngineShaderManager::GlobalOpacity), (GLfloat)q->state()->opacity);
+        opacityUniformDirty = false;
+    }
+
+    if (matrixUniformDirty && shaderManager->hasComplexGeometry()) {
+        shaderManager->currentProgram()->setUniformValue(location(QOpenGLEngineShaderManager::Matrix),
+                                                         pmvMatrix);
+        matrixUniformDirty = false;
+    }
+
+    return changed;
+}
+
+void QOpenGL2PaintEngineExPrivate::composite(const QOpenGLRect& boundingRect)
+{
+    setCoords(staticVertexCoordinateArray, boundingRect);
+
+    uploadData(QT_VERTEX_COORDS_ATTR, staticVertexCoordinateArray, 8);
+    funcs.glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
+}
+
+// Draws the vertex array as a set of <vertexArrayStops.size()> triangle fans.
+void QOpenGL2PaintEngineExPrivate::drawVertexArrays(const float *data, int *stops, int stopCount,
+                                                GLenum primitive)
+{
+    // Now setup the pointer to the vertex array:
+    uploadData(QT_VERTEX_COORDS_ATTR, data, stops[stopCount-1] * 2);
+
+    int previousStop = 0;
+    for (int i=0; i<stopCount; ++i) {
+        int stop = stops[i];
+
+        funcs.glDrawArrays(primitive, previousStop, stop - previousStop);
+        previousStop = stop;
+    }
+}
+
+/////////////////////////////////// Public Methods //////////////////////////////////////////
+
+QOpenGL2PaintEngineEx::QOpenGL2PaintEngineEx()
+    : QPaintEngineEx(*(new QOpenGL2PaintEngineExPrivate(this)))
+{
+    gccaps &= ~QPaintEngine::RasterOpModes;
+}
+
+QOpenGL2PaintEngineEx::~QOpenGL2PaintEngineEx()
+{
+}
+
+void QOpenGL2PaintEngineEx::fill(const QVectorPath &path, const QBrush &brush)
+{
+    Q_D(QOpenGL2PaintEngineEx);
+
+    if (qbrush_style(brush) == Qt::NoBrush)
+        return;
+    ensureActive();
+    d->setBrush(brush);
+    d->fill(path);
+}
+
+Q_GUI_EXPORT extern bool qt_scaleForTransform(const QTransform &transform, qreal *scale); // qtransform.cpp
+
+
+void QOpenGL2PaintEngineEx::stroke(const QVectorPath &path, const QPen &pen)
+{
+    Q_D(QOpenGL2PaintEngineEx);
+
+    const QBrush &penBrush = qpen_brush(pen);
+    if (qpen_style(pen) == Qt::NoPen || qbrush_style(penBrush) == Qt::NoBrush)
+        return;
+
+    QOpenGL2PaintEngineState *s = state();
+    if (qt_pen_is_cosmetic(pen, state()->renderHints) && !qt_scaleForTransform(s->transform(), nullptr)) {
+        // QTriangulatingStroker class is not meant to support cosmetically sheared strokes.
+        QPaintEngineEx::stroke(path, pen);
+        return;
+    }
+
+    ensureActive();
+    d->setBrush(penBrush);
+    d->stroke(path, pen);
+}
+
+void QOpenGL2PaintEngineExPrivate::stroke(const QVectorPath &path, const QPen &pen)
+{
+    const QOpenGL2PaintEngineState *s = q->state();
+    if (snapToPixelGrid) {
+        snapToPixelGrid = false;
+        matrixDirty = true;
+    }
+
+    const Qt::PenStyle penStyle = qpen_style(pen);
+    const QBrush &penBrush = qpen_brush(pen);
+    const bool opaque = penBrush.isOpaque() && s->opacity > 0.99;
+
+    transferMode(BrushDrawingMode);
+
+    // updateMatrix() is responsible for setting the inverse scale on
+    // the strokers, so we need to call it here and not wait for
+    // prepareForDraw() down below.
+    updateMatrix();
+
+    QRectF clip = q->state()->matrix.inverted().mapRect(q->state()->clipEnabled
+                                                        ? q->state()->rectangleClip
+                                                        : QRectF(0, 0, width, height));
+
+    if (penStyle == Qt::SolidLine) {
+        stroker.process(path, pen, clip, s->renderHints);
+
+    } else { // Some sort of dash
+        dasher.process(path, pen, clip, s->renderHints);
+
+        QVectorPath dashStroke(dasher.points(),
+                               dasher.elementCount(),
+                               dasher.elementTypes());
+        stroker.process(dashStroke, pen, clip, s->renderHints);
+    }
+
+    if (!stroker.vertexCount())
+        return;
+
+    if (opaque) {
+        prepareForDraw(opaque);
+
+        uploadData(QT_VERTEX_COORDS_ATTR, stroker.vertices(), stroker.vertexCount());
+        funcs.glDrawArrays(GL_TRIANGLE_STRIP, 0, stroker.vertexCount() / 2);
+    } else {
+        qreal width = qpen_widthf(pen) / 2;
+        if (width == 0)
+            width = 0.5;
+        qreal extra = pen.joinStyle() == Qt::MiterJoin
+                      ? qMax(pen.miterLimit() * width, width)
+                      : width;
+
+        if (qt_pen_is_cosmetic(pen, q->state()->renderHints))
+            extra = extra * inverseScale;
+
+        QRectF bounds = path.controlPointRect().adjusted(-extra, -extra, extra, extra);
+
+        fillStencilWithVertexArray(stroker.vertices(), stroker.vertexCount() / 2,
+                                      nullptr, 0, bounds, QOpenGL2PaintEngineExPrivate::TriStripStrokeFillMode);
+
+        funcs.glStencilOp(GL_KEEP, GL_REPLACE, GL_REPLACE);
+
+        // Pass when any bit is set, replace stencil value with 0
+        funcs.glStencilFunc(GL_NOTEQUAL, 0, GL_STENCIL_HIGH_BIT);
+        prepareForDraw(false);
+
+        // Stencil the brush onto the dest buffer
+        composite(bounds);
+
+        funcs.glStencilMask(0);
+
+        updateClipScissorTest();
+    }
+}
+
+void QOpenGL2PaintEngineEx::penChanged() { }
+void QOpenGL2PaintEngineEx::brushChanged() { }
+void QOpenGL2PaintEngineEx::brushOriginChanged() { }
+
+void QOpenGL2PaintEngineEx::opacityChanged()
+{
+//    qDebug("QOpenGL2PaintEngineEx::opacityChanged()");
+    Q_D(QOpenGL2PaintEngineEx);
+    state()->opacityChanged = true;
+
+    Q_ASSERT(d->shaderManager);
+    d->brushUniformsDirty = true;
+    d->opacityUniformDirty = true;
+}
+
+void QOpenGL2PaintEngineEx::compositionModeChanged()
+{
+//     qDebug("QOpenGL2PaintEngineEx::compositionModeChanged()");
+    Q_D(QOpenGL2PaintEngineEx);
+    state()->compositionModeChanged = true;
+    d->compositionModeDirty = true;
+}
+
+void QOpenGL2PaintEngineEx::renderHintsChanged()
+{
+    state()->renderHintsChanged = true;
+
+#ifndef QT_OPENGL_ES_2
+    if (!QOpenGLContext::currentContext()->isOpenGLES()) {
+        Q_D(QOpenGL2PaintEngineEx);
+QT_WARNING_PUSH
+QT_WARNING_DISABLE_DEPRECATED
+        if ((state()->renderHints & QPainter::Antialiasing)
+#if QT_DEPRECATED_SINCE(5, 14)
+            || (state()->renderHints & QPainter::HighQualityAntialiasing)
+#endif
+            )
+            d->funcs.glEnable(GL_MULTISAMPLE);
+        else
+            d->funcs.glDisable(GL_MULTISAMPLE);
+QT_WARNING_POP
+    }
+#endif // QT_OPENGL_ES_2
+
+    Q_D(QOpenGL2PaintEngineEx);
+
+    // This is a somewhat sneaky way of conceptually making the next call to
+    // updateTexture() use FoceUpdate for the TextureUpdateMode. We need this
+    // as new render hints may require updating the filter mode.
+    d->lastTextureUsed = GLuint(-1);
+
+    d->brushTextureDirty = true;
+//    qDebug("QOpenGL2PaintEngineEx::renderHintsChanged() not implemented!");
+}
+
+void QOpenGL2PaintEngineEx::transformChanged()
+{
+    Q_D(QOpenGL2PaintEngineEx);
+    d->matrixDirty = true;
+    state()->matrixChanged = true;
+}
+
+
+static const QRectF scaleRect(const QRectF &r, qreal sx, qreal sy)
+{
+    return QRectF(r.x() * sx, r.y() * sy, r.width() * sx, r.height() * sy);
+}
+
+void QOpenGL2PaintEngineEx::drawPixmap(const QRectF& dest, const QPixmap & pixmap, const QRectF & src)
+{
+    Q_D(QOpenGL2PaintEngineEx);
+    QOpenGLContext *ctx = d->ctx;
+
+    // Draw pixmaps that are really images as images since drawImage has
+    // better handling of non-default image formats.
+    if (pixmap.paintEngine()->type() == QPaintEngine::Raster && !pixmap.isQBitmap())
+        return drawImage(dest, pixmap.toImage(), src);
+
+    int max_texture_size = ctx->d_func()->maxTextureSize();
+    if (pixmap.width() > max_texture_size || pixmap.height() > max_texture_size) {
+        QPixmap scaled = pixmap.scaled(max_texture_size, max_texture_size, Qt::KeepAspectRatio);
+
+        const qreal sx = scaled.width() / qreal(pixmap.width());
+        const qreal sy = scaled.height() / qreal(pixmap.height());
+
+        drawPixmap(dest, scaled, scaleRect(src, sx, sy));
+        return;
+    }
+
+    ensureActive();
+    d->transferMode(ImageDrawingMode);
+
+    GLenum filterMode = state()->renderHints & QPainter::SmoothPixmapTransform ? GL_LINEAR : GL_NEAREST;
+    d->updateTexture(QT_IMAGE_TEXTURE_UNIT, pixmap, GL_CLAMP_TO_EDGE, filterMode);
+
+    bool isBitmap = pixmap.isQBitmap();
+    bool isOpaque = !isBitmap && !pixmap.hasAlpha();
+
+    d->shaderManager->setSrcPixelType(isBitmap ? QOpenGLEngineShaderManager::PatternSrc : QOpenGLEngineShaderManager::ImageSrc);
+
+    QOpenGLRect srcRect(src.left(), src.top(), src.right(), src.bottom());
+    d->drawTexture(dest, srcRect, pixmap.size(), isOpaque, isBitmap);
+}
+
+void QOpenGL2PaintEngineEx::drawImage(const QRectF& dest, const QImage& image, const QRectF& src,
+                        Qt::ImageConversionFlags)
+{
+    Q_D(QOpenGL2PaintEngineEx);
+    QOpenGLContext *ctx = d->ctx;
+
+    int max_texture_size = ctx->d_func()->maxTextureSize();
+    if (image.width() > max_texture_size || image.height() > max_texture_size) {
+        QImage scaled = image.scaled(max_texture_size, max_texture_size, Qt::KeepAspectRatio);
+
+        const qreal sx = scaled.width() / qreal(image.width());
+        const qreal sy = scaled.height() / qreal(image.height());
+
+        drawImage(dest, scaled, scaleRect(src, sx, sy));
+        return;
+    }
+
+    ensureActive();
+    d->transferMode(ImageDrawingMode);
+
+    QOpenGLTextureUploader::BindOptions bindOption = QOpenGLTextureUploader::PremultipliedAlphaBindOption;
+    // Use specialized bind for formats we have specialized shaders for.
+    switch (image.format()) {
+    case QImage::Format_RGBA8888:
+    case QImage::Format_ARGB32:
+    case QImage::Format_RGBA64:
+        d->shaderManager->setSrcPixelType(QOpenGLEngineShaderManager::NonPremultipliedImageSrc);
+        bindOption = { };
+        break;
+    case QImage::Format_Alpha8:
+        if (ctx->functions()->hasOpenGLFeature(QOpenGLFunctions::TextureRGFormats)) {
+            d->shaderManager->setSrcPixelType(QOpenGLEngineShaderManager::AlphaImageSrc);
+            bindOption = QOpenGLTextureUploader::UseRedForAlphaAndLuminanceBindOption;
+        } else
+            d->shaderManager->setSrcPixelType(QOpenGLEngineShaderManager::ImageSrc);
+        break;
+    case QImage::Format_Grayscale8:
+    case QImage::Format_Grayscale16:
+        if (ctx->functions()->hasOpenGLFeature(QOpenGLFunctions::TextureRGFormats)) {
+            d->shaderManager->setSrcPixelType(QOpenGLEngineShaderManager::GrayscaleImageSrc);
+            bindOption = QOpenGLTextureUploader::UseRedForAlphaAndLuminanceBindOption;
+        } else
+            d->shaderManager->setSrcPixelType(QOpenGLEngineShaderManager::ImageSrc);
+        break;
+    default:
+        d->shaderManager->setSrcPixelType(QOpenGLEngineShaderManager::ImageSrc);
+        break;
+    }
+
+    ImageWithBindOptions imageWithOptions = { image, bindOption };
+    GLenum filterMode = state()->renderHints & QPainter::SmoothPixmapTransform ? GL_LINEAR : GL_NEAREST;
+    d->updateTexture(QT_IMAGE_TEXTURE_UNIT, imageWithOptions, GL_CLAMP_TO_EDGE, filterMode);
+
+    d->drawTexture(dest, src, image.size(), !image.hasAlphaChannel());
+}
+
+void QOpenGL2PaintEngineEx::drawStaticTextItem(QStaticTextItem *textItem)
+{
+    Q_D(QOpenGL2PaintEngineEx);
+
+    ensureActive();
+
+    QPainterState *s = state();
+
+    QFontEngine *fontEngine = textItem->fontEngine();
+    if (shouldDrawCachedGlyphs(fontEngine, s->matrix)) {
+        QFontEngine::GlyphFormat glyphFormat = fontEngine->glyphFormat != QFontEngine::Format_None
+                                                ? fontEngine->glyphFormat : d->glyphCacheFormat;
+        if (glyphFormat == QFontEngine::Format_A32) {
+            if (d->device->context()->format().alphaBufferSize() > 0 || s->matrix.type() > QTransform::TxTranslate
+                || (s->composition_mode != QPainter::CompositionMode_Source
+                && s->composition_mode != QPainter::CompositionMode_SourceOver))
+            {
+                glyphFormat = QFontEngine::Format_A8;
+            }
+        }
+
+        d->drawCachedGlyphs(glyphFormat, textItem);
+    } else {
+        QPaintEngineEx::drawStaticTextItem(textItem);
+    }
+}
+
+bool QOpenGL2PaintEngineEx::drawTexture(const QRectF &dest, GLuint textureId, const QSize &size, const QRectF &src)
+{
+    Q_D(QOpenGL2PaintEngineEx);
+    if (!d->shaderManager)
+        return false;
+
+    ensureActive();
+    d->transferMode(ImageDrawingMode);
+
+    GLenum filterMode = state()->renderHints & QPainter::SmoothPixmapTransform ? GL_LINEAR : GL_NEAREST;
+    d->updateTexture(QT_IMAGE_TEXTURE_UNIT, textureId, GL_CLAMP_TO_EDGE, filterMode);
+
+    d->shaderManager->setSrcPixelType(QOpenGLEngineShaderManager::ImageSrc);
+
+    QOpenGLRect srcRect(src.left(), src.bottom(), src.right(), src.top());
+    d->drawTexture(dest, srcRect, size, false);
+
+    return true;
+}
+
+void QOpenGL2PaintEngineEx::drawTextItem(const QPointF &p, const QTextItem &textItem)
+{
+    Q_D(QOpenGL2PaintEngineEx);
+
+    ensureActive();
+    QOpenGL2PaintEngineState *s = state();
+
+    const QTextItemInt &ti = static_cast<const QTextItemInt &>(textItem);
+
+    QTransform::TransformationType txtype = s->matrix.type();
+
+    QFontEngine::GlyphFormat glyphFormat = ti.fontEngine->glyphFormat != QFontEngine::Format_None
+                                                ? ti.fontEngine->glyphFormat : d->glyphCacheFormat;
+
+    if (glyphFormat == QFontEngine::Format_A32) {
+        if (d->device->context()->format().alphaBufferSize() > 0 || txtype > QTransform::TxTranslate
+            || (state()->composition_mode != QPainter::CompositionMode_Source
+            && state()->composition_mode != QPainter::CompositionMode_SourceOver))
+        {
+            glyphFormat = QFontEngine::Format_A8;
+        }
+    }
+
+    if (shouldDrawCachedGlyphs(ti.fontEngine, s->matrix)) {
+        QVarLengthArray<QFixedPoint> positions;
+        QVarLengthArray<glyph_t> glyphs;
+        QTransform matrix = QTransform::fromTranslate(p.x(), p.y());
+        ti.fontEngine->getGlyphPositions(ti.glyphs, matrix, ti.flags, glyphs, positions);
+
+        {
+            QStaticTextItem staticTextItem;
+            staticTextItem.setFontEngine(ti.fontEngine);
+            staticTextItem.glyphs = glyphs.data();
+            staticTextItem.numGlyphs = glyphs.size();
+            staticTextItem.glyphPositions = positions.data();
+
+            d->drawCachedGlyphs(glyphFormat, &staticTextItem);
+        }
+        return;
+    }
+
+    QPaintEngineEx::drawTextItem(p, ti);
+}
+
+namespace {
+
+    class QOpenGLStaticTextUserData: public QStaticTextUserData
+    {
+    public:
+        QOpenGLStaticTextUserData()
+            : QStaticTextUserData(OpenGLUserData), cacheSize(0, 0), cacheSerialNumber(0)
+        {
+        }
+
+        ~QOpenGLStaticTextUserData()
+        {
+        }
+
+        QSize cacheSize;
+        QOpenGL2PEXVertexArray vertexCoordinateArray;
+        QOpenGL2PEXVertexArray textureCoordinateArray;
+        QFontEngine::GlyphFormat glyphFormat;
+        int cacheSerialNumber;
+    };
+
+}
+
+
+// #define QT_OPENGL_DRAWCACHEDGLYPHS_INDEX_ARRAY_VBO
+
+bool QOpenGL2PaintEngineEx::shouldDrawCachedGlyphs(QFontEngine *fontEngine, const QTransform &t) const
+{
+    // The paint engine does not support projected cached glyph drawing
+    if (t.type() == QTransform::TxProject)
+        return false;
+
+    // The font engine might not support filling the glyph cache
+    // with the given transform applied, in which case we need to
+    // fall back to the QPainterPath code-path.
+    if (!fontEngine->supportsTransformation(t)) {
+        // Except that drawing paths is slow, so for scales between
+        // 0.5 and 2.0 we leave the glyph cache untransformed and deal
+        // with the transform ourselves when painting, resulting in
+        // drawing 1x cached glyphs with a smooth-scale.
+        float det = t.determinant();
+        if (det >= 0.25f && det <= 4.f) {
+            // Assuming the baseclass still agrees
+            return QPaintEngineEx::shouldDrawCachedGlyphs(fontEngine, t);
+        }
+
+        return false; // Fall back to path-drawing
+    }
+
+    return QPaintEngineEx::shouldDrawCachedGlyphs(fontEngine, t);
+}
+
+void QOpenGL2PaintEngineExPrivate::drawCachedGlyphs(QFontEngine::GlyphFormat glyphFormat,
+                                                QStaticTextItem *staticTextItem)
+{
+    Q_Q(QOpenGL2PaintEngineEx);
+
+    QOpenGL2PaintEngineState *s = q->state();
+
+    void *cacheKey = ctx; // use context, not the shareGroup() -> the GL glyph cache uses FBOs which may not be shareable
+    bool recreateVertexArrays = false;
+
+    QTransform glyphCacheTransform;
+    QFontEngine *fe = staticTextItem->fontEngine();
+    if (fe->supportsTransformation(s->matrix)) {
+        // The font-engine supports rendering glyphs with the current transform, so we
+        // build a glyph-cache with the scale pre-applied, so that the cache contains
+        // glyphs with the appropriate resolution in the case of retina displays.
+        glyphCacheTransform = s->matrix.type() < QTransform::TxRotate ?
+            QTransform::fromScale(qAbs(s->matrix.m11()), qAbs(s->matrix.m22())) :
+            QTransform::fromScale(
+                QVector2D(s->matrix.m11(), s->matrix.m12()).length(),
+                QVector2D(s->matrix.m21(), s->matrix.m22()).length());
+    }
+
+    QOpenGLTextureGlyphCache *cache =
+            (QOpenGLTextureGlyphCache *) fe->glyphCache(cacheKey, glyphFormat, glyphCacheTransform);
+    if (!cache || cache->glyphFormat() != glyphFormat || cache->contextGroup() == nullptr) {
+        cache = new QOpenGLTextureGlyphCache(glyphFormat, glyphCacheTransform);
+        fe->setGlyphCache(cacheKey, cache);
+        recreateVertexArrays = true;
+    }
+
+    if (staticTextItem->userDataNeedsUpdate) {
+        recreateVertexArrays = true;
+    } else if (staticTextItem->userData() == nullptr) {
+        recreateVertexArrays = true;
+    } else if (staticTextItem->userData()->type != QStaticTextUserData::OpenGLUserData) {
+        recreateVertexArrays = true;
+    } else {
+        QOpenGLStaticTextUserData *userData = static_cast<QOpenGLStaticTextUserData *>(staticTextItem->userData());
+        if (userData->glyphFormat != glyphFormat) {
+            recreateVertexArrays = true;
+        } else if (userData->cacheSerialNumber != cache->serialNumber()) {
+            recreateVertexArrays = true;
+        }
+    }
+
+    // We only need to update the cache with new glyphs if we are actually going to recreate the vertex arrays.
+    // If the cache size has changed, we do need to regenerate the vertices, but we don't need to repopulate the
+    // cache so this text is performed before we test if the cache size has changed.
+    if (recreateVertexArrays) {
+        cache->setPaintEnginePrivate(this);
+        if (!cache->populate(fe, staticTextItem->numGlyphs,
+                             staticTextItem->glyphs, staticTextItem->glyphPositions)) {
+            // No space for glyphs in cache. We need to reset it and try again.
+            cache->clear();
+            cache->populate(fe, staticTextItem->numGlyphs,
+                            staticTextItem->glyphs, staticTextItem->glyphPositions);
+        }
+
+        if (cache->hasPendingGlyphs()) {
+            // Filling in the glyphs binds and sets parameters, so we need to
+            // ensure that the glyph cache doesn't mess with whatever unit
+            // is currently active. Note that the glyph cache internally
+            // uses the image texture unit for blitting to the cache, while
+            // we switch between image and mask units when drawing.
+            static const GLenum glypchCacheTextureUnit = QT_IMAGE_TEXTURE_UNIT;
+            activateTextureUnit(glypchCacheTextureUnit);
+
+            cache->fillInPendingGlyphs();
+
+            // We assume the cache can be trusted on which texture was bound
+            lastTextureUsed = cache->texture();
+
+            // But since the brush and image texture units are possibly shared
+            // we may have to re-bind brush textures after filling in the cache.
+            brushTextureDirty = (QT_BRUSH_TEXTURE_UNIT == glypchCacheTextureUnit);
+        }
+        cache->setPaintEnginePrivate(nullptr);
+    }
+
+    if (cache->width() == 0 || cache->height() == 0)
+        return;
+
+    if (glyphFormat == QFontEngine::Format_ARGB)
+        transferMode(ImageArrayDrawingMode);
+    else
+        transferMode(TextDrawingMode);
+
+    int margin = fe->glyphMargin(glyphFormat);
+
+    GLfloat dx = 1.0 / cache->width();
+    GLfloat dy = 1.0 / cache->height();
+
+    // Use global arrays by default
+    QOpenGL2PEXVertexArray *vertexCoordinates = &vertexCoordinateArray;
+    QOpenGL2PEXVertexArray *textureCoordinates = &textureCoordinateArray;
+
+    if (staticTextItem->useBackendOptimizations) {
+        QOpenGLStaticTextUserData *userData = nullptr;
+
+        if (staticTextItem->userData() == nullptr
+            || staticTextItem->userData()->type != QStaticTextUserData::OpenGLUserData) {
+
+            userData = new QOpenGLStaticTextUserData();
+            staticTextItem->setUserData(userData);
+
+        } else {
+            userData = static_cast<QOpenGLStaticTextUserData*>(staticTextItem->userData());
+        }
+
+        userData->glyphFormat = glyphFormat;
+        userData->cacheSerialNumber = cache->serialNumber();
+
+        // Use cache if backend optimizations is turned on
+        vertexCoordinates = &userData->vertexCoordinateArray;
+        textureCoordinates = &userData->textureCoordinateArray;
+
+        QSize size(cache->width(), cache->height());
+        if (userData->cacheSize != size) {
+            recreateVertexArrays = true;
+            userData->cacheSize = size;
+        }
+    }
+
+    if (recreateVertexArrays) {
+        vertexCoordinates->clear();
+        textureCoordinates->clear();
+
+        bool supportsSubPixelPositions = fe->supportsSubPixelPositions();
+        for (int i=0; i<staticTextItem->numGlyphs; ++i) {
+            QFixed subPixelPosition;
+            if (supportsSubPixelPositions)
+                subPixelPosition = fe->subPixelPositionForX(staticTextItem->glyphPositions[i].x);
+
+            QTextureGlyphCache::GlyphAndSubPixelPosition glyph(staticTextItem->glyphs[i], subPixelPosition);
+
+            const QTextureGlyphCache::Coord &c = cache->coords[glyph];
+            if (c.isNull())
+                continue;
+
+            int x = qFloor(staticTextItem->glyphPositions[i].x.toReal() * cache->transform().m11()) + c.baseLineX - margin;
+            int y = qRound(staticTextItem->glyphPositions[i].y.toReal() * cache->transform().m22()) - c.baseLineY - margin;
+
+            vertexCoordinates->addQuad(QRectF(x, y, c.w, c.h));
+            textureCoordinates->addQuad(QRectF(c.x*dx, c.y*dy, c.w * dx, c.h * dy));
+        }
+
+        staticTextItem->userDataNeedsUpdate = false;
+    }
+
+    int numGlyphs = vertexCoordinates->vertexCount() / 4;
+    if (numGlyphs == 0)
+        return;
+
+    if (elementIndices.size() < numGlyphs*6) {
+        Q_ASSERT(elementIndices.size() % 6 == 0);
+        int j = elementIndices.size() / 6 * 4;
+        while (j < numGlyphs*4) {
+            elementIndices.append(j + 0);
+            elementIndices.append(j + 0);
+            elementIndices.append(j + 1);
+            elementIndices.append(j + 2);
+            elementIndices.append(j + 3);
+            elementIndices.append(j + 3);
+
+            j += 4;
+        }
+
+#if defined(QT_OPENGL_DRAWCACHEDGLYPHS_INDEX_ARRAY_VBO)
+        if (elementIndicesVBOId == 0)
+            funcs.glGenBuffers(1, &elementIndicesVBOId);
+
+        funcs.glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, elementIndicesVBOId);
+        funcs.glBufferData(GL_ELEMENT_ARRAY_BUFFER, elementIndices.size() * sizeof(GLushort),
+                           elementIndices.constData(), GL_STATIC_DRAW);
+#endif
+    } else {
+#if defined(QT_OPENGL_DRAWCACHEDGLYPHS_INDEX_ARRAY_VBO)
+        funcs.glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, elementIndicesVBOId);
+#endif
+    }
+
+    if (glyphFormat != QFontEngine::Format_ARGB || recreateVertexArrays) {
+        uploadData(QT_VERTEX_COORDS_ATTR, (GLfloat*)vertexCoordinates->data(), vertexCoordinates->vertexCount() * 2);
+        uploadData(QT_TEXTURE_COORDS_ATTR, (GLfloat*)textureCoordinates->data(), textureCoordinates->vertexCount() * 2);
+    }
+
+    if (!snapToPixelGrid) {
+        snapToPixelGrid = true;
+        matrixDirty = true;
+    }
+
+    QBrush pensBrush = q->state()->pen.brush();
+    setBrush(pensBrush);
+
+    if (glyphFormat == QFontEngine::Format_A32) {
+
+        // Subpixel antialiasing without gamma correction
+
+        QPainter::CompositionMode compMode = q->state()->composition_mode;
+        Q_ASSERT(compMode == QPainter::CompositionMode_Source
+            || compMode == QPainter::CompositionMode_SourceOver);
+
+        shaderManager->setMaskType(QOpenGLEngineShaderManager::SubPixelMaskPass1);
+
+        if (pensBrush.style() == Qt::SolidPattern) {
+            // Solid patterns can get away with only one pass.
+            QColor c = pensBrush.color();
+            qreal oldOpacity = q->state()->opacity;
+            if (compMode == QPainter::CompositionMode_Source) {
+                c = qt_premultiplyColor(c, q->state()->opacity);
+                q->state()->opacity = 1;
+                opacityUniformDirty = true;
+            }
+
+            compositionModeDirty = false; // I can handle this myself, thank you very much
+            prepareForCachedGlyphDraw(*cache);
+
+            // prepareForCachedGlyphDraw() have set the opacity on the current shader, so the opacity state can now be reset.
+            if (compMode == QPainter::CompositionMode_Source) {
+                q->state()->opacity = oldOpacity;
+                opacityUniformDirty = true;
+            }
+
+            funcs.glEnable(GL_BLEND);
+            funcs.glBlendFunc(GL_CONSTANT_COLOR, GL_ONE_MINUS_SRC_COLOR);
+            funcs.glBlendColor(c.redF(), c.greenF(), c.blueF(), c.alphaF());
+        } else {
+            // Other brush styles need two passes.
+
+            qreal oldOpacity = q->state()->opacity;
+            if (compMode == QPainter::CompositionMode_Source) {
+                q->state()->opacity = 1;
+                opacityUniformDirty = true;
+                pensBrush = Qt::white;
+                setBrush(pensBrush);
+            }
+
+            compositionModeDirty = false; // I can handle this myself, thank you very much
+            prepareForCachedGlyphDraw(*cache);
+            funcs.glEnable(GL_BLEND);
+            funcs.glBlendFunc(GL_ZERO, GL_ONE_MINUS_SRC_COLOR);
+
+            updateTexture(QT_MASK_TEXTURE_UNIT, cache->texture(), GL_REPEAT, GL_NEAREST, ForceUpdate);
+
+#if defined(QT_OPENGL_DRAWCACHEDGLYPHS_INDEX_ARRAY_VBO)
+            funcs.glDrawElements(GL_TRIANGLE_STRIP, 6 * numGlyphs, GL_UNSIGNED_SHORT, 0);
+#else
+            const bool useIndexVbo = uploadIndexData(elementIndices.data(), GL_UNSIGNED_SHORT, 6 * numGlyphs);
+            funcs.glDrawElements(GL_TRIANGLE_STRIP, 6 * numGlyphs, GL_UNSIGNED_SHORT, useIndexVbo ? nullptr : elementIndices.data());
+#endif
+
+            shaderManager->setMaskType(QOpenGLEngineShaderManager::SubPixelMaskPass2);
+
+            if (compMode == QPainter::CompositionMode_Source) {
+                q->state()->opacity = oldOpacity;
+                opacityUniformDirty = true;
+                pensBrush = q->state()->pen.brush();
+                setBrush(pensBrush);
+            }
+
+            compositionModeDirty = false;
+            prepareForCachedGlyphDraw(*cache);
+            funcs.glEnable(GL_BLEND);
+            funcs.glBlendFunc(GL_ONE, GL_ONE);
+        }
+        compositionModeDirty = true;
+    } else if (glyphFormat == QFontEngine::Format_ARGB) {
+        currentBrush = noBrush;
+        shaderManager->setSrcPixelType(QOpenGLEngineShaderManager::ImageSrc);
+        if (prepareForCachedGlyphDraw(*cache))
+            shaderManager->currentProgram()->setUniformValue(location(QOpenGLEngineShaderManager::ImageTexture), QT_IMAGE_TEXTURE_UNIT);
+    } else {
+        // Grayscale/mono glyphs
+
+        shaderManager->setMaskType(QOpenGLEngineShaderManager::PixelMask);
+        prepareForCachedGlyphDraw(*cache);
+    }
+
+    GLenum textureUnit = QT_MASK_TEXTURE_UNIT;
+    if (glyphFormat == QFontEngine::Format_ARGB)
+        textureUnit = QT_IMAGE_TEXTURE_UNIT;
+
+    QOpenGLTextureGlyphCache::FilterMode filterMode = (s->matrix.type() > QTransform::TxTranslate) ?
+        QOpenGLTextureGlyphCache::Linear : QOpenGLTextureGlyphCache::Nearest;
+
+    GLenum glFilterMode = filterMode == QOpenGLTextureGlyphCache::Linear ? GL_LINEAR : GL_NEAREST;
+
+    TextureUpdateMode updateMode = UpdateIfNeeded;
+    if (cache->filterMode() != filterMode) {
+        updateMode = ForceUpdate;
+        cache->setFilterMode(filterMode);
+    }
+
+    updateTexture(textureUnit, cache->texture(), GL_REPEAT, glFilterMode, updateMode);
+
+#if defined(QT_OPENGL_DRAWCACHEDGLYPHS_INDEX_ARRAY_VBO)
+    funcs.glDrawElements(GL_TRIANGLE_STRIP, 6 * numGlyphs, GL_UNSIGNED_SHORT, 0);
+    funcs.glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+#else
+    const bool useIndexVbo = uploadIndexData(elementIndices.data(), GL_UNSIGNED_SHORT, 6 * numGlyphs);
+    funcs.glDrawElements(GL_TRIANGLE_STRIP, 6 * numGlyphs, GL_UNSIGNED_SHORT, useIndexVbo ? nullptr : elementIndices.data());
+#endif
+}
+
+void QOpenGL2PaintEngineEx::drawPixmapFragments(const QPainter::PixmapFragment *fragments, int fragmentCount, const QPixmap &pixmap,
+                                            QPainter::PixmapFragmentHints hints)
+{
+    Q_D(QOpenGL2PaintEngineEx);
+    // Use fallback for extended composition modes.
+    if (state()->composition_mode > QPainter::CompositionMode_Plus) {
+        QPaintEngineEx::drawPixmapFragments(fragments, fragmentCount, pixmap, hints);
+        return;
+    }
+
+    ensureActive();
+    int max_texture_size = d->ctx->d_func()->maxTextureSize();
+    if (pixmap.width() > max_texture_size || pixmap.height() > max_texture_size) {
+        QPixmap scaled = pixmap.scaled(max_texture_size, max_texture_size, Qt::KeepAspectRatio);
+        d->drawPixmapFragments(fragments, fragmentCount, scaled, hints);
+    } else {
+        d->drawPixmapFragments(fragments, fragmentCount, pixmap, hints);
+    }
+}
+
+
+void QOpenGL2PaintEngineExPrivate::drawPixmapFragments(const QPainter::PixmapFragment *fragments,
+                                                   int fragmentCount, const QPixmap &pixmap,
+                                                   QPainter::PixmapFragmentHints hints)
+{
+    GLfloat dx = 1.0f / pixmap.size().width();
+    GLfloat dy = 1.0f / pixmap.size().height();
+
+    vertexCoordinateArray.clear();
+    textureCoordinateArray.clear();
+    opacityArray.reset();
+
+    if (snapToPixelGrid) {
+        snapToPixelGrid = false;
+        matrixDirty = true;
+    }
+
+    bool allOpaque = true;
+
+    for (int i = 0; i < fragmentCount; ++i) {
+        qreal s = 0;
+        qreal c = 1;
+        if (fragments[i].rotation != 0) {
+            s = qFastSin(qDegreesToRadians(fragments[i].rotation));
+            c = qFastCos(qDegreesToRadians(fragments[i].rotation));
+        }
+
+        qreal right = 0.5 * fragments[i].scaleX * fragments[i].width;
+        qreal bottom = 0.5 * fragments[i].scaleY * fragments[i].height;
+        QOpenGLPoint bottomRight(right * c - bottom * s, right * s + bottom * c);
+        QOpenGLPoint bottomLeft(-right * c - bottom * s, -right * s + bottom * c);
+
+        vertexCoordinateArray.addVertex(bottomRight.x + fragments[i].x, bottomRight.y + fragments[i].y);
+        vertexCoordinateArray.addVertex(-bottomLeft.x + fragments[i].x, -bottomLeft.y + fragments[i].y);
+        vertexCoordinateArray.addVertex(-bottomRight.x + fragments[i].x, -bottomRight.y + fragments[i].y);
+        vertexCoordinateArray.addVertex(-bottomRight.x + fragments[i].x, -bottomRight.y + fragments[i].y);
+        vertexCoordinateArray.addVertex(bottomLeft.x + fragments[i].x, bottomLeft.y + fragments[i].y);
+        vertexCoordinateArray.addVertex(bottomRight.x + fragments[i].x, bottomRight.y + fragments[i].y);
+
+        QOpenGLRect src(fragments[i].sourceLeft * dx, fragments[i].sourceTop * dy,
+                    (fragments[i].sourceLeft + fragments[i].width) * dx,
+                    (fragments[i].sourceTop + fragments[i].height) * dy);
+
+        textureCoordinateArray.addVertex(src.right, src.bottom);
+        textureCoordinateArray.addVertex(src.right, src.top);
+        textureCoordinateArray.addVertex(src.left, src.top);
+        textureCoordinateArray.addVertex(src.left, src.top);
+        textureCoordinateArray.addVertex(src.left, src.bottom);
+        textureCoordinateArray.addVertex(src.right, src.bottom);
+
+        qreal opacity = fragments[i].opacity * q->state()->opacity;
+        opacityArray << opacity << opacity << opacity << opacity << opacity << opacity;
+        allOpaque &= (opacity >= 0.99f);
+    }
+
+    transferMode(ImageOpacityArrayDrawingMode);
+
+    GLenum filterMode = q->state()->renderHints & QPainter::SmoothPixmapTransform ? GL_LINEAR : GL_NEAREST;
+    updateTexture(QT_IMAGE_TEXTURE_UNIT, pixmap, GL_CLAMP_TO_EDGE, filterMode);
+
+    bool isBitmap = pixmap.isQBitmap();
+    bool isOpaque = !isBitmap && (!pixmap.hasAlpha() || (hints & QPainter::OpaqueHint)) && allOpaque;
+
+    // Setup for texture drawing
+    currentBrush = noBrush;
+    shaderManager->setSrcPixelType(isBitmap ? QOpenGLEngineShaderManager::PatternSrc
+                                            : QOpenGLEngineShaderManager::ImageSrc);
+    if (prepareForDraw(isOpaque))
+        shaderManager->currentProgram()->setUniformValue(location(QOpenGLEngineShaderManager::ImageTexture), QT_IMAGE_TEXTURE_UNIT);
+
+    if (isBitmap) {
+        QColor col = qt_premultiplyColor(q->state()->pen.color(), (GLfloat)q->state()->opacity);
+        shaderManager->currentProgram()->setUniformValue(location(QOpenGLEngineShaderManager::PatternColor), col);
+    }
+
+    funcs.glDrawArrays(GL_TRIANGLES, 0, 6 * fragmentCount);
+}
+
+bool QOpenGL2PaintEngineEx::begin(QPaintDevice *pdev)
+{
+    Q_D(QOpenGL2PaintEngineEx);
+
+    Q_ASSERT(pdev->devType() == QInternal::OpenGL);
+    d->device = static_cast<QOpenGLPaintDevice*>(pdev);
+
+    if (!d->device)
+        return false;
+
+    d->device->ensureActiveTarget();
+
+    if (d->device->context() != QOpenGLContext::currentContext() || !d->device->context()) {
+        qWarning("QPainter::begin(): QOpenGLPaintDevice's context needs to be current");
+        return false;
+    }
+
+    if (d->ctx != QOpenGLContext::currentContext()
+            || (d->ctx && QOpenGLContext::currentContext() && d->ctx->format() != QOpenGLContext::currentContext()->format())) {
+        d->vertexBuffer.destroy();
+        d->texCoordBuffer.destroy();
+        d->opacityBuffer.destroy();
+        d->indexBuffer.destroy();
+        d->vao.destroy();
+    }
+
+    d->ctx = QOpenGLContext::currentContext();
+    d->ctx->d_func()->active_engine = this;
+
+    QOpenGLPaintDevicePrivate::get(d->device)->beginPaint();
+
+    d->funcs.initializeOpenGLFunctions();
+
+    // Generate a new Vertex Array Object if we don't have one already.  We can
+    // only hit the VAO-based path when using a core profile context.  This is
+    // because while non-core contexts can support VAOs via extensions, legacy
+    // components like the QtOpenGL module do not know about VAOs. There are
+    // still tests for QGL-QOpenGL paint engine interoperability, so keep the
+    // status quo for now, and avoid introducing a VAO in non-core contexts.
+    const bool needsVAO = d->ctx->format().profile() == QSurfaceFormat::CoreProfile
+        && d->ctx->format().version() >= qMakePair(3, 2);
+    if (needsVAO && !d->vao.isCreated()) {
+        bool created = d->vao.create();
+
+        // If we managed to create it then we have a profile that supports VAOs
+        if (created) {
+            d->vao.bind();
+
+            // Generate a new Vertex Buffer Object if we don't have one already
+            if (!d->vertexBuffer.isCreated()) {
+                d->vertexBuffer.create();
+                // Set its usage to StreamDraw, we will use this buffer only a few times before refilling it
+                d->vertexBuffer.setUsagePattern(QOpenGLBuffer::StreamDraw);
+            }
+            if (!d->texCoordBuffer.isCreated()) {
+                d->texCoordBuffer.create();
+                d->texCoordBuffer.setUsagePattern(QOpenGLBuffer::StreamDraw);
+            }
+            if (!d->opacityBuffer.isCreated()) {
+                d->opacityBuffer.create();
+                d->opacityBuffer.setUsagePattern(QOpenGLBuffer::StreamDraw);
+            }
+            if (!d->indexBuffer.isCreated()) {
+                d->indexBuffer.create();
+                d->indexBuffer.setUsagePattern(QOpenGLBuffer::StreamDraw);
+            }
+        }
+    }
+
+    for (int i = 0; i < QT_GL_VERTEX_ARRAY_TRACKED_COUNT; ++i)
+        d->vertexAttributeArraysEnabledState[i] = false;
+
+    const QSize sz = d->device->size();
+    d->width = sz.width();
+    d->height = sz.height();
+    d->mode = BrushDrawingMode;
+    d->brushTextureDirty = true;
+    d->brushUniformsDirty = true;
+    d->matrixUniformDirty = true;
+    d->matrixDirty = true;
+    d->compositionModeDirty = true;
+    d->opacityUniformDirty = true;
+    d->needsSync = true;
+    d->useSystemClip = !systemClip().isEmpty();
+    d->currentBrush = QBrush();
+
+    d->dirtyStencilRegion = QRect(0, 0, d->width, d->height);
+    d->stencilClean = true;
+
+    d->shaderManager = new QOpenGLEngineShaderManager(d->ctx);
+
+    d->funcs.glDisable(GL_STENCIL_TEST);
+    d->funcs.glDisable(GL_DEPTH_TEST);
+    d->funcs.glDisable(GL_SCISSOR_TEST);
+
+    d->glyphCacheFormat = QFontEngine::Format_A8;
+
+#ifndef QT_OPENGL_ES_2
+    if (!QOpenGLContext::currentContext()->isOpenGLES()) {
+        d->funcs.glDisable(GL_MULTISAMPLE);
+        d->glyphCacheFormat = QFontEngine::Format_A32;
+        d->multisamplingAlwaysEnabled = false;
+    } else
+#endif // QT_OPENGL_ES_2
+    {
+        // OpenGL ES can't switch MSAA off, so if the gl paint device is
+        // multisampled, it's always multisampled.
+        d->multisamplingAlwaysEnabled = d->device->context()->format().samples() > 1;
+    }
+
+    return true;
+}
+
+bool QOpenGL2PaintEngineEx::end()
+{
+    Q_D(QOpenGL2PaintEngineEx);
+
+    QOpenGLPaintDevicePrivate::get(d->device)->endPaint();
+
+    QOpenGLContext *ctx = d->ctx;
+    d->funcs.glUseProgram(0);
+    d->transferMode(BrushDrawingMode);
+
+    ctx->d_func()->active_engine = nullptr;
+
+    d->resetGLState();
+
+    delete d->shaderManager;
+    d->shaderManager = nullptr;
+    d->currentBrush = QBrush();
+
+#ifdef QT_OPENGL_CACHE_AS_VBOS
+    if (!d->unusedVBOSToClean.isEmpty()) {
+        glDeleteBuffers(d->unusedVBOSToClean.size(), d->unusedVBOSToClean.constData());
+        d->unusedVBOSToClean.clear();
+    }
+    if (!d->unusedIBOSToClean.isEmpty()) {
+        glDeleteBuffers(d->unusedIBOSToClean.size(), d->unusedIBOSToClean.constData());
+        d->unusedIBOSToClean.clear();
+    }
+#endif
+
+    return false;
+}
+
+void QOpenGL2PaintEngineEx::ensureActive()
+{
+    Q_D(QOpenGL2PaintEngineEx);
+    QOpenGLContext *ctx = d->ctx;
+
+    if (d->vao.isCreated())
+        d->vao.bind();
+
+    if (isActive() && ctx->d_func()->active_engine != this) {
+        ctx->d_func()->active_engine = this;
+        d->needsSync = true;
+    }
+
+    if (d->needsSync) {
+        d->device->ensureActiveTarget();
+
+        d->transferMode(BrushDrawingMode);
+        d->funcs.glViewport(0, 0, d->width, d->height);
+        d->needsSync = false;
+        d->shaderManager->setDirty();
+        d->syncGlState();
+        for (int i = 0; i < 3; ++i)
+            d->vertexAttribPointers[i] = (GLfloat*)-1; // Assume the pointers are clobbered
+        setState(state());
+    }
+}
+
+void QOpenGL2PaintEngineExPrivate::updateClipScissorTest()
+{
+    Q_Q(QOpenGL2PaintEngineEx);
+    if (q->state()->clipTestEnabled) {
+        funcs.glEnable(GL_STENCIL_TEST);
+        funcs.glStencilFunc(GL_LEQUAL, q->state()->currentClip, ~GL_STENCIL_HIGH_BIT);
+    } else {
+        funcs.glDisable(GL_STENCIL_TEST);
+        funcs.glStencilFunc(GL_ALWAYS, 0, 0xff);
+    }
+
+#ifdef QT_GL_NO_SCISSOR_TEST
+    currentScissorBounds = QRect(0, 0, width, height);
+#else
+    QRect bounds = q->state()->rectangleClip;
+    if (!q->state()->clipEnabled) {
+        if (useSystemClip)
+            bounds = systemClip.boundingRect();
+        else
+            bounds = QRect(0, 0, width, height);
+    } else {
+        if (useSystemClip)
+            bounds = bounds.intersected(systemClip.boundingRect());
+        else
+            bounds = bounds.intersected(QRect(0, 0, width, height));
+    }
+
+    currentScissorBounds = bounds;
+
+    if (bounds == QRect(0, 0, width, height)) {
+        funcs.glDisable(GL_SCISSOR_TEST);
+    } else {
+        funcs.glEnable(GL_SCISSOR_TEST);
+        setScissor(bounds);
+    }
+#endif
+}
+
+void QOpenGL2PaintEngineExPrivate::setScissor(const QRect &rect)
+{
+    const int left = rect.left();
+    const int width = rect.width();
+    int bottom = height - (rect.top() + rect.height());
+    if (device->paintFlipped()) {
+        bottom = rect.top();
+    }
+    const int height = rect.height();
+
+    funcs.glScissor(left, bottom, width, height);
+}
+
+void QOpenGL2PaintEngineEx::clipEnabledChanged()
+{
+    Q_D(QOpenGL2PaintEngineEx);
+
+    state()->clipChanged = true;
+
+    if (painter()->hasClipping())
+        d->regenerateClip();
+    else
+        d->systemStateChanged();
+}
+
+void QOpenGL2PaintEngineExPrivate::clearClip(uint value)
+{
+    dirtyStencilRegion -= currentScissorBounds;
+
+    funcs.glStencilMask(0xff);
+    funcs.glClearStencil(value);
+    funcs.glClear(GL_STENCIL_BUFFER_BIT);
+    funcs.glStencilMask(0x0);
+
+    q->state()->needsClipBufferClear = false;
+}
+
+void QOpenGL2PaintEngineExPrivate::writeClip(const QVectorPath &path, uint value)
+{
+    transferMode(BrushDrawingMode);
+
+    if (snapToPixelGrid) {
+        snapToPixelGrid = false;
+        matrixDirty = true;
+    }
+
+    if (matrixDirty)
+        updateMatrix();
+
+    stencilClean = false;
+
+    const bool singlePass = !path.hasWindingFill()
+        && (((q->state()->currentClip == maxClip - 1) && q->state()->clipTestEnabled)
+            || q->state()->needsClipBufferClear);
+    const uint referenceClipValue = q->state()->needsClipBufferClear ? 1 : q->state()->currentClip;
+
+    if (q->state()->needsClipBufferClear)
+        clearClip(1);
+
+    if (path.isEmpty()) {
+        funcs.glEnable(GL_STENCIL_TEST);
+        funcs.glStencilFunc(GL_LEQUAL, value, ~GL_STENCIL_HIGH_BIT);
+        return;
+    }
+
+    if (q->state()->clipTestEnabled)
+        funcs.glStencilFunc(GL_LEQUAL, q->state()->currentClip, ~GL_STENCIL_HIGH_BIT);
+    else
+        funcs.glStencilFunc(GL_ALWAYS, 0, 0xff);
+
+    vertexCoordinateArray.clear();
+    vertexCoordinateArray.addPath(path, inverseScale, false);
+
+    if (!singlePass)
+        fillStencilWithVertexArray(vertexCoordinateArray, path.hasWindingFill());
+
+    funcs.glColorMask(false, false, false, false);
+    funcs.glEnable(GL_STENCIL_TEST);
+    useSimpleShader();
+
+    if (singlePass) {
+        // Under these conditions we can set the new stencil value in a single
+        // pass, by using the current value and the "new value" as the toggles
+
+        funcs.glStencilFunc(GL_LEQUAL, referenceClipValue, ~GL_STENCIL_HIGH_BIT);
+        funcs.glStencilOp(GL_KEEP, GL_INVERT, GL_INVERT);
+        funcs.glStencilMask(value ^ referenceClipValue);
+
+        drawVertexArrays(vertexCoordinateArray, GL_TRIANGLE_FAN);
+    } else {
+        funcs.glStencilOp(GL_KEEP, GL_REPLACE, GL_REPLACE);
+        funcs.glStencilMask(0xff);
+
+        if (!q->state()->clipTestEnabled && path.hasWindingFill()) {
+            // Pass when any clip bit is set, set high bit
+            funcs.glStencilFunc(GL_NOTEQUAL, GL_STENCIL_HIGH_BIT, ~GL_STENCIL_HIGH_BIT);
+            composite(vertexCoordinateArray.boundingRect());
+        }
+
+        // Pass when high bit is set, replace stencil value with new clip value
+        funcs.glStencilFunc(GL_NOTEQUAL, value, GL_STENCIL_HIGH_BIT);
+
+        composite(vertexCoordinateArray.boundingRect());
+    }
+
+    funcs.glStencilFunc(GL_LEQUAL, value, ~GL_STENCIL_HIGH_BIT);
+    funcs.glStencilMask(0);
+
+    funcs.glColorMask(true, true, true, true);
+}
+
+void QOpenGL2PaintEngineEx::clip(const QVectorPath &path, Qt::ClipOperation op)
+{
+//     qDebug("QOpenGL2PaintEngineEx::clip()");
+    Q_D(QOpenGL2PaintEngineEx);
+
+    state()->clipChanged = true;
+
+    ensureActive();
+
+    if (op == Qt::ReplaceClip) {
+        op = Qt::IntersectClip;
+        if (d->hasClipOperations()) {
+            d->systemStateChanged();
+            state()->canRestoreClip = false;
+        }
+    }
+
+#ifndef QT_GL_NO_SCISSOR_TEST
+    if (!path.isEmpty() && op == Qt::IntersectClip && (path.shape() == QVectorPath::RectangleHint)) {
+        const QPointF* const points = reinterpret_cast<const QPointF*>(path.points());
+        QRectF rect(points[0], points[2]);
+
+        if (state()->matrix.type() <= QTransform::TxScale
+            || (state()->matrix.type() == QTransform::TxRotate
+                && qFuzzyIsNull(state()->matrix.m11())
+                && qFuzzyIsNull(state()->matrix.m22())))
+        {
+            state()->rectangleClip = state()->rectangleClip.intersected(state()->matrix.mapRect(rect).toRect());
+            d->updateClipScissorTest();
+            return;
+        }
+    }
+#endif
+
+    const QRect pathRect = state()->matrix.mapRect(path.controlPointRect()).toAlignedRect();
+
+    switch (op) {
+    case Qt::NoClip:
+        if (d->useSystemClip) {
+            state()->clipTestEnabled = true;
+            state()->currentClip = 1;
+        } else {
+            state()->clipTestEnabled = false;
+        }
+        state()->rectangleClip = QRect(0, 0, d->width, d->height);
+        state()->canRestoreClip = false;
+        d->updateClipScissorTest();
+        break;
+    case Qt::IntersectClip:
+        state()->rectangleClip = state()->rectangleClip.intersected(pathRect);
+        d->updateClipScissorTest();
+        d->resetClipIfNeeded();
+        ++d->maxClip;
+        d->writeClip(path, d->maxClip);
+        state()->currentClip = d->maxClip;
+        state()->clipTestEnabled = true;
+        break;
+    default:
+        break;
+    }
+}
+
+void QOpenGL2PaintEngineExPrivate::regenerateClip()
+{
+    systemStateChanged();
+    replayClipOperations();
+}
+
+void QOpenGL2PaintEngineExPrivate::systemStateChanged()
+{
+    Q_Q(QOpenGL2PaintEngineEx);
+
+    q->state()->clipChanged = true;
+
+    if (systemClip.isEmpty()) {
+        useSystemClip = false;
+    } else {
+        if (q->paintDevice()->devType() == QInternal::Widget && currentClipDevice) {
+            //QWidgetPrivate *widgetPrivate = qt_widget_private(static_cast<QWidget *>(currentClipDevice)->window());
+            //useSystemClip = widgetPrivate->extra && widgetPrivate->extra->inRenderWithPainter;
+            useSystemClip = true;
+        } else {
+            useSystemClip = true;
+        }
+    }
+
+    q->state()->clipTestEnabled = false;
+    q->state()->needsClipBufferClear = true;
+
+    q->state()->currentClip = 1;
+    maxClip = 1;
+
+    q->state()->rectangleClip = useSystemClip ? systemClip.boundingRect() : QRect(0, 0, width, height);
+    updateClipScissorTest();
+
+    if (systemClip.rectCount() == 1) {
+        if (systemClip.boundingRect() == QRect(0, 0, width, height))
+            useSystemClip = false;
+#ifndef QT_GL_NO_SCISSOR_TEST
+        // scissoring takes care of the system clip
+        return;
+#endif
+    }
+
+    if (useSystemClip) {
+        clearClip(0);
+
+        QPainterPath path;
+        path.addRegion(systemClip);
+
+        q->state()->currentClip = 0;
+        writeClip(qtVectorPathForPath(q->state()->matrix.inverted().map(path)), 1);
+        q->state()->currentClip = 1;
+        q->state()->clipTestEnabled = true;
+    }
+}
+
+void QOpenGL2PaintEngineEx::setState(QPainterState *new_state)
+{
+    //     qDebug("QOpenGL2PaintEngineEx::setState()");
+
+    Q_D(QOpenGL2PaintEngineEx);
+
+    QOpenGL2PaintEngineState *s = static_cast<QOpenGL2PaintEngineState *>(new_state);
+    QOpenGL2PaintEngineState *old_state = state();
+
+    QPaintEngineEx::setState(s);
+
+    if (s->isNew) {
+        // Newly created state object.  The call to setState()
+        // will either be followed by a call to begin(), or we are
+        // setting the state as part of a save().
+        s->isNew = false;
+        return;
+    }
+
+    // Setting the state as part of a restore().
+
+    if (old_state == s || old_state->renderHintsChanged)
+        renderHintsChanged();
+
+    if (old_state == s || old_state->matrixChanged)
+        d->matrixDirty = true;
+
+    if (old_state == s || old_state->compositionModeChanged)
+        d->compositionModeDirty = true;
+
+    if (old_state == s || old_state->opacityChanged)
+        d->opacityUniformDirty = true;
+
+    if (old_state == s || old_state->clipChanged) {
+        if (old_state && old_state != s && old_state->canRestoreClip) {
+            d->updateClipScissorTest();
+            d->funcs.glDepthFunc(GL_LEQUAL);
+        } else {
+            d->regenerateClip();
+        }
+    }
+}
+
+QPainterState *QOpenGL2PaintEngineEx::createState(QPainterState *orig) const
+{
+    if (orig)
+        const_cast<QOpenGL2PaintEngineEx *>(this)->ensureActive();
+
+    QOpenGL2PaintEngineState *s;
+    if (!orig)
+        s = new QOpenGL2PaintEngineState();
+    else
+        s = new QOpenGL2PaintEngineState(*static_cast<QOpenGL2PaintEngineState *>(orig));
+
+    s->matrixChanged = false;
+    s->compositionModeChanged = false;
+    s->opacityChanged = false;
+    s->renderHintsChanged = false;
+    s->clipChanged = false;
+
+    return s;
+}
+
+QOpenGL2PaintEngineState::QOpenGL2PaintEngineState(QOpenGL2PaintEngineState &other)
+    : QPainterState(other)
+{
+    isNew = true;
+    needsClipBufferClear = other.needsClipBufferClear;
+    clipTestEnabled = other.clipTestEnabled;
+    currentClip = other.currentClip;
+    canRestoreClip = other.canRestoreClip;
+    rectangleClip = other.rectangleClip;
+}
+
+QOpenGL2PaintEngineState::QOpenGL2PaintEngineState()
+{
+    isNew = true;
+    needsClipBufferClear = true;
+    clipTestEnabled = false;
+    canRestoreClip = true;
+}
+
+QOpenGL2PaintEngineState::~QOpenGL2PaintEngineState()
+{
+}
+
+void QOpenGL2PaintEngineExPrivate::setVertexAttribArrayEnabled(int arrayIndex, bool enabled)
+{
+    Q_ASSERT(arrayIndex < QT_GL_VERTEX_ARRAY_TRACKED_COUNT);
+
+    if (vertexAttributeArraysEnabledState[arrayIndex] && !enabled)
+        funcs.glDisableVertexAttribArray(arrayIndex);
+
+    if (!vertexAttributeArraysEnabledState[arrayIndex] && enabled)
+        funcs.glEnableVertexAttribArray(arrayIndex);
+
+    vertexAttributeArraysEnabledState[arrayIndex] = enabled;
+}
+
+void QOpenGL2PaintEngineExPrivate::syncGlState()
+{
+    for (int i = 0; i < QT_GL_VERTEX_ARRAY_TRACKED_COUNT; ++i) {
+        if (vertexAttributeArraysEnabledState[i])
+            funcs.glEnableVertexAttribArray(i);
+        else
+            funcs.glDisableVertexAttribArray(i);
+    }
+}
+
+
+QT_END_NAMESPACE
diff --git a/src/opengl/qopenglpaintengine_p.h b/src/opengl/qopenglpaintengine_p.h
new file mode 100644
index 0000000000..9dc92e3810
--- /dev/null
+++ b/src/opengl/qopenglpaintengine_p.h
@@ -0,0 +1,395 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtOpenGL module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QOPENGLPAINTENGINE_P_H
+#define QOPENGLPAINTENGINE_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QDebug>
+
+#include <qopenglpaintdevice.h>
+
+#include <private/qpaintengineex_p.h>
+#include <private/qopenglengineshadermanager_p.h>
+#include <private/qopengl2pexvertexarray_p.h>
+#include <private/qfontengine_p.h>
+#include <private/qdatabuffer_p.h>
+#include <private/qtriangulatingstroker_p.h>
+
+#include <private/qopenglextensions_p.h>
+
+#include <QOpenGLVertexArrayObject>
+#include <QOpenGLBuffer>
+
+enum EngineMode {
+    ImageDrawingMode,
+    TextDrawingMode,
+    BrushDrawingMode,
+    ImageArrayDrawingMode,
+    ImageOpacityArrayDrawingMode
+};
+
+QT_BEGIN_NAMESPACE
+
+#define GL_STENCIL_HIGH_BIT         GLuint(0x80)
+#define QT_UNKNOWN_TEXTURE_UNIT     GLuint(-1)
+#define QT_DEFAULT_TEXTURE_UNIT     GLuint(0)
+#define QT_BRUSH_TEXTURE_UNIT       GLuint(0)
+#define QT_IMAGE_TEXTURE_UNIT       GLuint(0) //Can be the same as brush texture unit
+#define QT_MASK_TEXTURE_UNIT        GLuint(1)
+#define QT_BACKGROUND_TEXTURE_UNIT  GLuint(2)
+
+class QOpenGL2PaintEngineExPrivate;
+
+class QOpenGL2PaintEngineState : public QPainterState
+{
+public:
+    QOpenGL2PaintEngineState(QOpenGL2PaintEngineState &other);
+    QOpenGL2PaintEngineState();
+    ~QOpenGL2PaintEngineState();
+
+    uint isNew : 1;
+    uint needsClipBufferClear : 1;
+    uint clipTestEnabled : 1;
+    uint canRestoreClip : 1;
+    uint matrixChanged : 1;
+    uint compositionModeChanged : 1;
+    uint opacityChanged : 1;
+    uint renderHintsChanged : 1;
+    uint clipChanged : 1;
+    uint currentClip : 8;
+
+    QRect rectangleClip;
+};
+
+class Q_OPENGL_EXPORT QOpenGL2PaintEngineEx : public QPaintEngineEx
+{
+    Q_DECLARE_PRIVATE(QOpenGL2PaintEngineEx)
+public:
+    QOpenGL2PaintEngineEx();
+    ~QOpenGL2PaintEngineEx();
+
+    bool begin(QPaintDevice *device) override;
+    void ensureActive();
+    bool end() override;
+
+    virtual void clipEnabledChanged() override;
+    virtual void penChanged() override;
+    virtual void brushChanged() override;
+    virtual void brushOriginChanged() override;
+    virtual void opacityChanged() override;
+    virtual void compositionModeChanged() override;
+    virtual void renderHintsChanged() override;
+    virtual void transformChanged() override;
+
+    virtual void drawPixmap(const QRectF &r, const QPixmap &pm, const QRectF &sr) override;
+    virtual void drawPixmapFragments(const QPainter::PixmapFragment *fragments, int fragmentCount, const QPixmap &pixmap,
+                                     QPainter::PixmapFragmentHints hints) override;
+    virtual void drawImage(const QRectF &r, const QImage &pm, const QRectF &sr,
+                           Qt::ImageConversionFlags flags = Qt::AutoColor) override;
+    virtual void drawTextItem(const QPointF &p, const QTextItem &textItem) override;
+    virtual void fill(const QVectorPath &path, const QBrush &brush) override;
+    virtual void stroke(const QVectorPath &path, const QPen &pen) override;
+    virtual void clip(const QVectorPath &path, Qt::ClipOperation op) override;
+
+    virtual void drawStaticTextItem(QStaticTextItem *textItem) override;
+
+    bool drawTexture(const QRectF &r, GLuint textureId, const QSize &size, const QRectF &sr);
+
+    Type type() const override { return OpenGL2; }
+
+    virtual void setState(QPainterState *s) override;
+    virtual QPainterState *createState(QPainterState *orig) const override;
+    inline QOpenGL2PaintEngineState *state() {
+        return static_cast<QOpenGL2PaintEngineState *>(QPaintEngineEx::state());
+    }
+    inline const QOpenGL2PaintEngineState *state() const {
+        return static_cast<const QOpenGL2PaintEngineState *>(QPaintEngineEx::state());
+    }
+
+    void beginNativePainting() override;
+    void endNativePainting() override;
+
+    void invalidateState();
+
+    void setRenderTextActive(bool);
+
+    bool isNativePaintingActive() const;
+    bool requiresPretransformedGlyphPositions(QFontEngine *, const QTransform &) const override { return false; }
+    bool shouldDrawCachedGlyphs(QFontEngine *, const QTransform &) const override;
+
+private:
+    Q_DISABLE_COPY_MOVE(QOpenGL2PaintEngineEx)
+
+    friend class QOpenGLEngineShaderManager;
+};
+
+// This probably needs to grow to GL_MAX_VERTEX_ATTRIBS, but 3 is ok for now as that's
+// all the GL2 engine uses:
+#define QT_GL_VERTEX_ARRAY_TRACKED_COUNT 3
+
+class QOpenGL2PaintEngineExPrivate : public QPaintEngineExPrivate
+{
+    Q_DECLARE_PUBLIC(QOpenGL2PaintEngineEx)
+public:
+    enum StencilFillMode {
+        OddEvenFillMode,
+        WindingFillMode,
+        TriStripStrokeFillMode
+    };
+
+    QOpenGL2PaintEngineExPrivate(QOpenGL2PaintEngineEx *q_ptr) :
+            q(q_ptr),
+            shaderManager(nullptr),
+            width(0), height(0),
+            ctx(nullptr),
+            useSystemClip(true),
+            elementIndicesVBOId(0),
+            opacityArray(0),
+            snapToPixelGrid(false),
+            nativePaintingActive(false),
+            inverseScale(1),
+            lastTextureUnitUsed(QT_UNKNOWN_TEXTURE_UNIT),
+            vertexBuffer(QOpenGLBuffer::VertexBuffer),
+            texCoordBuffer(QOpenGLBuffer::VertexBuffer),
+            opacityBuffer(QOpenGLBuffer::VertexBuffer),
+            indexBuffer(QOpenGLBuffer::IndexBuffer)
+    { }
+
+    ~QOpenGL2PaintEngineExPrivate();
+
+    void updateBrushTexture();
+    void updateBrushUniforms();
+    void updateMatrix();
+    void updateCompositionMode();
+
+    enum TextureUpdateMode { UpdateIfNeeded, ForceUpdate };
+    template<typename T>
+    void updateTexture(GLenum textureUnit, const T &texture, GLenum wrapMode, GLenum filterMode, TextureUpdateMode updateMode = UpdateIfNeeded);
+    template<typename T>
+    GLuint bindTexture(const T &texture);
+    void activateTextureUnit(GLenum textureUnit);
+
+    void resetGLState();
+
+    // fill, stroke, drawTexture, drawPixmaps & drawCachedGlyphs are the main rendering entry-points,
+    // however writeClip can also be thought of as en entry point as it does similar things.
+    void fill(const QVectorPath &path);
+    void stroke(const QVectorPath &path, const QPen &pen);
+    void drawTexture(const QOpenGLRect& dest, const QOpenGLRect& src, const QSize &textureSize, bool opaque, bool pattern = false);
+    void drawPixmapFragments(const QPainter::PixmapFragment *fragments, int fragmentCount, const QPixmap &pixmap,
+                             QPainter::PixmapFragmentHints hints);
+    void drawCachedGlyphs(QFontEngine::GlyphFormat glyphFormat, QStaticTextItem *staticTextItem);
+
+    // Calls glVertexAttributePointer if the pointer has changed
+    inline void uploadData(unsigned int arrayIndex, const GLfloat *data, GLuint count);
+    inline bool uploadIndexData(const void *data, GLenum indexValueType, GLuint count);
+
+    // draws whatever is in the vertex array:
+    void drawVertexArrays(const float *data, int *stops, int stopCount, GLenum primitive);
+    void drawVertexArrays(QOpenGL2PEXVertexArray &vertexArray, GLenum primitive) {
+        drawVertexArrays((const float *) vertexArray.data(), vertexArray.stops(), vertexArray.stopCount(), primitive);
+    }
+
+    // Composites the bounding rect onto dest buffer:
+    void composite(const QOpenGLRect& boundingRect);
+
+    // Calls drawVertexArrays to render into stencil buffer:
+    void fillStencilWithVertexArray(const float *data, int count, int *stops, int stopCount, const QOpenGLRect &bounds, StencilFillMode mode);
+    void fillStencilWithVertexArray(QOpenGL2PEXVertexArray& vertexArray, bool useWindingFill) {
+        fillStencilWithVertexArray((const float *) vertexArray.data(), 0, vertexArray.stops(), vertexArray.stopCount(),
+                                   vertexArray.boundingRect(),
+                                   useWindingFill ? WindingFillMode : OddEvenFillMode);
+    }
+
+    void setBrush(const QBrush& brush);
+    void transferMode(EngineMode newMode);
+    bool prepareForDraw(bool srcPixelsAreOpaque); // returns true if the program has changed
+    bool prepareForCachedGlyphDraw(const QFontEngineGlyphCache &cache);
+    inline void useSimpleShader();
+    inline GLuint location(const QOpenGLEngineShaderManager::Uniform uniform) {
+        return shaderManager->getUniformLocation(uniform);
+    }
+
+    void clearClip(uint value);
+    void writeClip(const QVectorPath &path, uint value);
+    void resetClipIfNeeded();
+
+    void updateClipScissorTest();
+    void setScissor(const QRect &rect);
+    void regenerateClip();
+    void systemStateChanged() override;
+
+    void setVertexAttribArrayEnabled(int arrayIndex, bool enabled = true);
+    void syncGlState();
+
+    static QOpenGLEngineShaderManager* shaderManagerForEngine(QOpenGL2PaintEngineEx *engine) { return engine->d_func()->shaderManager; }
+    static QOpenGL2PaintEngineExPrivate *getData(QOpenGL2PaintEngineEx *engine) { return engine->d_func(); }
+    static void cleanupVectorPath(QPaintEngineEx *engine, void *data);
+
+    QOpenGLExtensions funcs;
+
+    QOpenGL2PaintEngineEx* q;
+    QOpenGLEngineShaderManager* shaderManager;
+    QOpenGLPaintDevice* device;
+    int width, height;
+    QOpenGLContext *ctx;
+    EngineMode mode;
+    QFontEngine::GlyphFormat glyphCacheFormat;
+
+    bool vertexAttributeArraysEnabledState[QT_GL_VERTEX_ARRAY_TRACKED_COUNT];
+
+    // Dirty flags
+    bool matrixDirty; // Implies matrix uniforms are also dirty
+    bool compositionModeDirty;
+    bool brushTextureDirty;
+    bool brushUniformsDirty;
+    bool opacityUniformDirty;
+    bool matrixUniformDirty;
+
+    bool stencilClean; // Has the stencil not been used for clipping so far?
+    bool useSystemClip;
+    QRegion dirtyStencilRegion;
+    QRect currentScissorBounds;
+    uint maxClip;
+
+    QBrush currentBrush; // May not be the state's brush!
+    const QBrush noBrush;
+
+    QImage currentBrushImage;
+
+    QOpenGL2PEXVertexArray vertexCoordinateArray;
+    QOpenGL2PEXVertexArray textureCoordinateArray;
+    QVector<GLushort> elementIndices;
+    GLuint elementIndicesVBOId;
+    QDataBuffer<GLfloat> opacityArray;
+    GLfloat staticVertexCoordinateArray[8];
+    GLfloat staticTextureCoordinateArray[8];
+
+    bool snapToPixelGrid;
+    bool nativePaintingActive;
+    GLfloat pmvMatrix[3][3];
+    GLfloat inverseScale;
+
+    GLenum lastTextureUnitUsed;
+    GLuint lastTextureUsed;
+
+    QOpenGLVertexArrayObject vao;
+    QOpenGLBuffer vertexBuffer;
+    QOpenGLBuffer texCoordBuffer;
+    QOpenGLBuffer opacityBuffer;
+    QOpenGLBuffer indexBuffer;
+
+    bool needsSync;
+    bool multisamplingAlwaysEnabled;
+
+    QTriangulatingStroker stroker;
+    QDashedStrokeProcessor dasher;
+
+    QVector<GLuint> unusedVBOSToClean;
+    QVector<GLuint> unusedIBOSToClean;
+
+    const GLfloat *vertexAttribPointers[3];
+};
+
+
+void QOpenGL2PaintEngineExPrivate::uploadData(unsigned int arrayIndex, const GLfloat *data, GLuint count)
+{
+    Q_ASSERT(arrayIndex < 3);
+
+    // If a vertex array object is created we have a profile that supports them
+    // and we will upload the data via a QOpenGLBuffer. Otherwise we will use
+    // the legacy way of uploading the data via glVertexAttribPointer.
+    if (vao.isCreated()) {
+        if (arrayIndex == QT_VERTEX_COORDS_ATTR) {
+            vertexBuffer.bind();
+            vertexBuffer.allocate(data, count * sizeof(float));
+        }
+        if (arrayIndex == QT_TEXTURE_COORDS_ATTR) {
+            texCoordBuffer.bind();
+            texCoordBuffer.allocate(data, count * sizeof(float));
+        }
+        if (arrayIndex == QT_OPACITY_ATTR) {
+            opacityBuffer.bind();
+            opacityBuffer.allocate(data, count * sizeof(float));
+        }
+        if (arrayIndex == QT_OPACITY_ATTR)
+            funcs.glVertexAttribPointer(arrayIndex, 1, GL_FLOAT, GL_FALSE, 0, nullptr);
+        else
+            funcs.glVertexAttribPointer(arrayIndex, 2, GL_FLOAT, GL_FALSE, 0, nullptr);
+    } else {
+        // If we already uploaded the data we don't have to do it again
+        if (data == vertexAttribPointers[arrayIndex])
+            return;
+
+        // Store the data in cache and upload it to the graphics card.
+        vertexAttribPointers[arrayIndex] = data;
+        if (arrayIndex == QT_OPACITY_ATTR)
+            funcs.glVertexAttribPointer(arrayIndex, 1, GL_FLOAT, GL_FALSE, 0, data);
+        else
+            funcs.glVertexAttribPointer(arrayIndex, 2, GL_FLOAT, GL_FALSE, 0, data);
+    }
+}
+
+bool QOpenGL2PaintEngineExPrivate::uploadIndexData(const void *data, GLenum indexValueType, GLuint count)
+{
+    // Follow the uploadData() logic: VBOs are used only when VAO support is available.
+    // Otherwise the legacy client-side pointer path is used.
+    if (vao.isCreated()) {
+        Q_ASSERT(indexValueType == GL_UNSIGNED_SHORT || indexValueType == GL_UNSIGNED_INT);
+        indexBuffer.bind();
+        indexBuffer.allocate(data, count * (indexValueType == GL_UNSIGNED_SHORT ? sizeof(quint16) : sizeof(quint32)));
+        return true;
+    }
+    return false;
+}
+
+QT_END_NAMESPACE
+
+#endif
diff --git a/src/opengl/qopenglshadercache_p.h b/src/opengl/qopenglshadercache_p.h
new file mode 100644
index 0000000000..88efa34216
--- /dev/null
+++ b/src/opengl/qopenglshadercache_p.h
@@ -0,0 +1,86 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtOpenGL module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#ifndef QOPENGLSHADERCACHE_P_H
+#define QOPENGLSHADERCACHE_P_H
+
+#include <QtOpenGL/qtopenglglobal.h>
+
+QT_BEGIN_NAMESPACE
+
+
+class QOpenGLShaderProgram;
+class QOpenGLContext;
+
+class CachedShader
+{
+public:
+    inline CachedShader(const QByteArray &, const QByteArray &)
+    {}
+
+    inline bool isCached()
+    {
+        return false;
+    }
+
+    inline bool load(QOpenGLShaderProgram *, QOpenGLContext *)
+    {
+        return false;
+    }
+
+    inline bool store(QOpenGLShaderProgram *, QOpenGLContext *)
+    {
+        return false;
+    }
+};
+
+QT_END_NAMESPACE
+
+#endif
diff --git a/src/opengl/qopengltexturecache.cpp b/src/opengl/qopengltexturecache.cpp
new file mode 100644
index 0000000000..5256c429e0
--- /dev/null
+++ b/src/opengl/qopengltexturecache.cpp
@@ -0,0 +1,198 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtOpenGL module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qopengltexturecache_p.h"
+#include <private/qopengltextureuploader_p.h>
+#include <qmath.h>
+#include <qopenglfunctions.h>
+#include <private/qimagepixmapcleanuphooks_p.h>
+#include <qpa/qplatformpixmap.h>
+
+QT_BEGIN_NAMESPACE
+
+class QOpenGLTextureCacheWrapper
+{
+public:
+    QOpenGLTextureCacheWrapper()
+    {
+        QImagePixmapCleanupHooks::instance()->addPlatformPixmapModificationHook(cleanupTexturesForPixmapData);
+        QImagePixmapCleanupHooks::instance()->addPlatformPixmapDestructionHook(cleanupTexturesForPixmapData);
+        QImagePixmapCleanupHooks::instance()->addImageHook(cleanupTexturesForCacheKey);
+    }
+
+    ~QOpenGLTextureCacheWrapper()
+    {
+        QImagePixmapCleanupHooks::instance()->removePlatformPixmapModificationHook(cleanupTexturesForPixmapData);
+        QImagePixmapCleanupHooks::instance()->removePlatformPixmapDestructionHook(cleanupTexturesForPixmapData);
+        QImagePixmapCleanupHooks::instance()->removeImageHook(cleanupTexturesForCacheKey);
+    }
+
+    QOpenGLTextureCache *cacheForContext(QOpenGLContext *context) {
+        QMutexLocker lock(&m_mutex);
+        return m_resource.value<QOpenGLTextureCache>(context);
+    }
+
+    static void cleanupTexturesForCacheKey(qint64 key);
+    static void cleanupTexturesForPixmapData(QPlatformPixmap *pmd);
+
+private:
+    QOpenGLMultiGroupSharedResource m_resource;
+    QMutex m_mutex;
+};
+
+Q_GLOBAL_STATIC(QOpenGLTextureCacheWrapper, qt_texture_caches)
+
+QOpenGLTextureCache *QOpenGLTextureCache::cacheForContext(QOpenGLContext *context)
+{
+    return qt_texture_caches()->cacheForContext(context);
+}
+
+void QOpenGLTextureCacheWrapper::cleanupTexturesForCacheKey(qint64 key)
+{
+    QList<QOpenGLSharedResource *> resources = qt_texture_caches()->m_resource.resources();
+    for (QList<QOpenGLSharedResource *>::iterator it = resources.begin(); it != resources.end(); ++it)
+        static_cast<QOpenGLTextureCache *>(*it)->invalidate(key);
+}
+
+void QOpenGLTextureCacheWrapper::cleanupTexturesForPixmapData(QPlatformPixmap *pmd)
+{
+    cleanupTexturesForCacheKey(pmd->cacheKey());
+}
+
+QOpenGLTextureCache::QOpenGLTextureCache(QOpenGLContext *ctx)
+    : QOpenGLSharedResource(ctx->shareGroup())
+    , m_cache(256 * 1024) // 256 MB cache
+{
+}
+
+QOpenGLTextureCache::~QOpenGLTextureCache()
+{
+}
+
+GLuint QOpenGLTextureCache::bindTexture(QOpenGLContext *context, const QPixmap &pixmap, QOpenGLTextureUploader::BindOptions options)
+{
+    if (pixmap.isNull())
+        return 0;
+    QMutexLocker locker(&m_mutex);
+    qint64 key = pixmap.cacheKey();
+
+    // A QPainter is active on the image - take the safe route and replace the texture.
+    if (!pixmap.paintingActive()) {
+        QOpenGLCachedTexture *entry = m_cache.object(key);
+        if (entry && entry->options() == options) {
+            context->functions()->glBindTexture(GL_TEXTURE_2D, entry->id());
+            return entry->id();
+        }
+    }
+
+    GLuint id = bindTexture(context, key, pixmap.toImage(), options);
+    if (id > 0)
+        QImagePixmapCleanupHooks::enableCleanupHooks(pixmap);
+
+    return id;
+}
+
+GLuint QOpenGLTextureCache::bindTexture(QOpenGLContext *context, const QImage &image, QOpenGLTextureUploader::BindOptions options)
+{
+    if (image.isNull())
+        return 0;
+    QMutexLocker locker(&m_mutex);
+    qint64 key = image.cacheKey();
+
+    // A QPainter is active on the image - take the safe route and replace the texture.
+    if (!image.paintingActive()) {
+        QOpenGLCachedTexture *entry = m_cache.object(key);
+        if (entry && entry->options() == options) {
+            context->functions()->glBindTexture(GL_TEXTURE_2D, entry->id());
+            return entry->id();
+        }
+    }
+
+    QImage img = image;
+    if (!context->functions()->hasOpenGLFeature(QOpenGLFunctions::NPOTTextures))
+        options |= QOpenGLTextureUploader::PowerOfTwoBindOption;
+
+    GLuint id = bindTexture(context, key, img, options);
+    if (id > 0)
+        QImagePixmapCleanupHooks::enableCleanupHooks(image);
+
+    return id;
+}
+
+GLuint QOpenGLTextureCache::bindTexture(QOpenGLContext *context, qint64 key, const QImage &image, QOpenGLTextureUploader::BindOptions options)
+{
+    GLuint id;
+    QOpenGLFunctions *funcs = context->functions();
+    funcs->glGenTextures(1, &id);
+    funcs->glBindTexture(GL_TEXTURE_2D, id);
+
+    int cost = QOpenGLTextureUploader::textureImage(GL_TEXTURE_2D, image, options);
+
+    m_cache.insert(key, new QOpenGLCachedTexture(id, options, context), cost / 1024);
+
+    return id;
+}
+
+void QOpenGLTextureCache::invalidate(qint64 key)
+{
+    QMutexLocker locker(&m_mutex);
+    m_cache.remove(key);
+}
+
+void QOpenGLTextureCache::invalidateResource()
+{
+    m_cache.clear();
+}
+
+void QOpenGLTextureCache::freeResource(QOpenGLContext *)
+{
+    Q_ASSERT(false); // the texture cache lives until the context group disappears
+}
+
+static void freeTexture(QOpenGLFunctions *funcs, GLuint id)
+{
+    funcs->glDeleteTextures(1, &id);
+}
+
+QOpenGLCachedTexture::QOpenGLCachedTexture(GLuint id, QOpenGLTextureUploader::BindOptions options, QOpenGLContext *context) : m_options(options)
+{
+    m_resource = new QOpenGLSharedResourceGuard(context, id, freeTexture);
+}
+
+QT_END_NAMESPACE
diff --git a/src/opengl/qopengltexturecache_p.h b/src/opengl/qopengltexturecache_p.h
new file mode 100644
index 0000000000..14e03ebea1
--- /dev/null
+++ b/src/opengl/qopengltexturecache_p.h
@@ -0,0 +1,108 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtOpenGL module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#ifndef QOPENGLTEXTURECACHE_P_H
+#define QOPENGLTEXTURECACHE_P_H
+
+#include <QtOpenGL/qtopenglglobal.h>
+#include <QHash>
+#include <QObject>
+#include <QCache>
+#include <private/qopenglcontext_p.h>
+#include <private/qopengltextureuploader_p.h>
+#include <QtCore/qmutex.h>
+
+QT_BEGIN_NAMESPACE
+
+class QOpenGLCachedTexture;
+
+class Q_OPENGL_EXPORT QOpenGLTextureCache : public QOpenGLSharedResource
+{
+public:
+    static QOpenGLTextureCache *cacheForContext(QOpenGLContext *context);
+
+    QOpenGLTextureCache(QOpenGLContext *);
+    ~QOpenGLTextureCache();
+
+    GLuint bindTexture(QOpenGLContext *context, const QPixmap &pixmap,
+                       QOpenGLTextureUploader::BindOptions options = QOpenGLTextureUploader::PremultipliedAlphaBindOption);
+    GLuint bindTexture(QOpenGLContext *context, const QImage &image,
+                       QOpenGLTextureUploader::BindOptions options = QOpenGLTextureUploader::PremultipliedAlphaBindOption);
+
+    void invalidate(qint64 key);
+
+    void invalidateResource() override;
+    void freeResource(QOpenGLContext *ctx) override;
+
+private:
+    GLuint bindTexture(QOpenGLContext *context, qint64 key, const QImage &image, QOpenGLTextureUploader::BindOptions options);
+
+    QMutex m_mutex;
+    QCache<quint64, QOpenGLCachedTexture> m_cache;
+};
+
+class QOpenGLCachedTexture
+{
+public:
+    QOpenGLCachedTexture(GLuint id, QOpenGLTextureUploader::BindOptions options, QOpenGLContext *context);
+    ~QOpenGLCachedTexture() { m_resource->free(); }
+
+    GLuint id() const { return m_resource->id(); }
+    QOpenGLTextureUploader::BindOptions options() const { return m_options; }
+
+private:
+    QOpenGLSharedResourceGuard *m_resource;
+    QOpenGLTextureUploader::BindOptions m_options;
+};
+
+QT_END_NAMESPACE
+
+#endif
+
diff --git a/src/opengl/qopengltextureglyphcache.cpp b/src/opengl/qopengltextureglyphcache.cpp
new file mode 100644
index 0000000000..66fd3a7507
--- /dev/null
+++ b/src/opengl/qopengltextureglyphcache.cpp
@@ -0,0 +1,485 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtOpenGL module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qopengltextureglyphcache_p.h"
+#include <private/qopenglpaintengine_p.h>
+#include "private/qopenglengineshadersource_p.h"
+#include <private/qopenglextensions_p.h>
+#include <qrgb.h>
+#include <private/qdrawhelper_p.h>
+
+QT_BEGIN_NAMESPACE
+
+
+static int next_qopengltextureglyphcache_serial_number()
+{
+    static QBasicAtomicInt serial = Q_BASIC_ATOMIC_INITIALIZER(0);
+    return 1 + serial.fetchAndAddRelaxed(1);
+}
+
+QOpenGLTextureGlyphCache::QOpenGLTextureGlyphCache(QFontEngine::GlyphFormat format, const QTransform &matrix, const QColor &color)
+    : QImageTextureGlyphCache(format, matrix, color)
+    , m_textureResource(nullptr)
+    , pex(nullptr)
+    , m_blitProgram(nullptr)
+    , m_filterMode(Nearest)
+    , m_serialNumber(next_qopengltextureglyphcache_serial_number())
+    , m_buffer(QOpenGLBuffer::VertexBuffer)
+{
+#ifdef QT_GL_TEXTURE_GLYPH_CACHE_DEBUG
+    qDebug(" -> QOpenGLTextureGlyphCache() %p for context %p.", this, QOpenGLContext::currentContext());
+#endif
+    m_vertexCoordinateArray[0] = -1.0f;
+    m_vertexCoordinateArray[1] = -1.0f;
+    m_vertexCoordinateArray[2] =  1.0f;
+    m_vertexCoordinateArray[3] = -1.0f;
+    m_vertexCoordinateArray[4] =  1.0f;
+    m_vertexCoordinateArray[5] =  1.0f;
+    m_vertexCoordinateArray[6] = -1.0f;
+    m_vertexCoordinateArray[7] =  1.0f;
+
+    m_textureCoordinateArray[0] = 0.0f;
+    m_textureCoordinateArray[1] = 0.0f;
+    m_textureCoordinateArray[2] = 1.0f;
+    m_textureCoordinateArray[3] = 0.0f;
+    m_textureCoordinateArray[4] = 1.0f;
+    m_textureCoordinateArray[5] = 1.0f;
+    m_textureCoordinateArray[6] = 0.0f;
+    m_textureCoordinateArray[7] = 1.0f;
+}
+
+QOpenGLTextureGlyphCache::~QOpenGLTextureGlyphCache()
+{
+#ifdef QT_GL_TEXTURE_GLYPH_CACHE_DEBUG
+    qDebug(" -> ~QOpenGLTextureGlyphCache() %p.", this);
+#endif
+    clear();
+}
+
+#if !defined(QT_OPENGL_ES_2)
+static inline bool isCoreProfile()
+{
+    return QOpenGLContext::currentContext()->format().profile() == QSurfaceFormat::CoreProfile;
+}
+#endif
+
+void QOpenGLTextureGlyphCache::createTextureData(int width, int height)
+{
+    QOpenGLContext *ctx = const_cast<QOpenGLContext *>(QOpenGLContext::currentContext());
+    if (ctx == nullptr) {
+        qWarning("QOpenGLTextureGlyphCache::createTextureData: Called with no context");
+        return;
+    }
+
+    // create in QImageTextureGlyphCache baseclass is meant to be called
+    // only to create the initial image and does not preserve the content,
+    // so we don't call when this function is called from resize.
+    if (ctx->d_func()->workaround_brokenFBOReadBack && image().isNull())
+        QImageTextureGlyphCache::createTextureData(width, height);
+
+    // Make the lower glyph texture size 16 x 16.
+    if (width < 16)
+        width = 16;
+    if (height < 16)
+        height = 16;
+
+    if (m_textureResource && !m_textureResource->m_texture) {
+        delete m_textureResource;
+        m_textureResource = nullptr;
+    }
+
+    if (!m_textureResource)
+        m_textureResource = new QOpenGLGlyphTexture(ctx);
+
+    QOpenGLFunctions *funcs = ctx->functions();
+    funcs->glGenTextures(1, &m_textureResource->m_texture);
+    funcs->glBindTexture(GL_TEXTURE_2D, m_textureResource->m_texture);
+
+    m_textureResource->m_width = width;
+    m_textureResource->m_height = height;
+
+    if (m_format == QFontEngine::Format_A32 || m_format == QFontEngine::Format_ARGB) {
+        QVarLengthArray<uchar> data(width * height * 4);
+        for (int i = 0; i < data.size(); ++i)
+            data[i] = 0;
+        funcs->glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, &data[0]);
+    } else {
+        QVarLengthArray<uchar> data(width * height);
+        for (int i = 0; i < data.size(); ++i)
+            data[i] = 0;
+#if !defined(QT_OPENGL_ES_2)
+        const GLint internalFormat = isCoreProfile() ? GL_R8 : GL_ALPHA;
+        const GLenum format = isCoreProfile() ? GL_RED : GL_ALPHA;
+#else
+        const GLint internalFormat = GL_ALPHA;
+        const GLenum format = GL_ALPHA;
+#endif
+        funcs->glTexImage2D(GL_TEXTURE_2D, 0, internalFormat, width, height, 0, format, GL_UNSIGNED_BYTE, &data[0]);
+    }
+
+    funcs->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+    funcs->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+    funcs->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+    funcs->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+    m_filterMode = Nearest;
+
+    if (!m_buffer.isCreated()) {
+        m_buffer.create();
+        m_buffer.bind();
+        static GLfloat buf[sizeof(m_vertexCoordinateArray) + sizeof(m_textureCoordinateArray)];
+        memcpy(buf, m_vertexCoordinateArray, sizeof(m_vertexCoordinateArray));
+        memcpy(buf + (sizeof(m_vertexCoordinateArray) / sizeof(GLfloat)),
+               m_textureCoordinateArray,
+               sizeof(m_textureCoordinateArray));
+        m_buffer.allocate(buf, sizeof(buf));
+        m_buffer.release();
+    }
+
+    if (!m_vao.isCreated())
+        m_vao.create();
+}
+
+void QOpenGLTextureGlyphCache::setupVertexAttribs()
+{
+    m_buffer.bind();
+    m_blitProgram->setAttributeBuffer(int(QT_VERTEX_COORDS_ATTR), GL_FLOAT, 0, 2);
+    m_blitProgram->setAttributeBuffer(int(QT_TEXTURE_COORDS_ATTR), GL_FLOAT, sizeof(m_vertexCoordinateArray), 2);
+    m_blitProgram->enableAttributeArray(int(QT_VERTEX_COORDS_ATTR));
+    m_blitProgram->enableAttributeArray(int(QT_TEXTURE_COORDS_ATTR));
+    m_buffer.release();
+}
+
+static void load_glyph_image_to_texture(QOpenGLContext *ctx,
+                                        QImage &img,
+                                        GLuint texture,
+                                        int tx, int ty)
+{
+    QOpenGLFunctions *funcs = ctx->functions();
+
+    const int imgWidth = img.width();
+    const int imgHeight = img.height();
+
+    if (img.format() == QImage::Format_Mono) {
+        img = img.convertToFormat(QImage::Format_Grayscale8);
+    } else if (img.depth() == 32) {
+        if (img.format() == QImage::Format_RGB32
+            // We need to make the alpha component equal to the average of the RGB values.
+            // This is needed when drawing sub-pixel antialiased text on translucent targets.
+#if Q_BYTE_ORDER == Q_BIG_ENDIAN
+            || img.format() == QImage::Format_ARGB32_Premultiplied
+#else
+            || (img.format() == QImage::Format_ARGB32_Premultiplied
+                && ctx->isOpenGLES())
+#endif
+            ) {
+            for (int y = 0; y < imgHeight; ++y) {
+                QRgb *src = (QRgb *) img.scanLine(y);
+                for (int x = 0; x < imgWidth; ++x) {
+                    int r = qRed(src[x]);
+                    int g = qGreen(src[x]);
+                    int b = qBlue(src[x]);
+                    int avg;
+                    if (img.format() == QImage::Format_RGB32)
+                        avg = (r + g + b + 1) / 3; // "+1" for rounding.
+                    else // Format_ARGB_Premultiplied
+                        avg = qAlpha(src[x]);
+
+                    src[x] = qRgba(r, g, b, avg);
+                    // swizzle the bits to accommodate for the GL_RGBA upload.
+#if Q_BYTE_ORDER != Q_BIG_ENDIAN
+                    if (ctx->isOpenGLES())
+#endif
+                        src[x] = ARGB2RGBA(src[x]);
+                }
+            }
+        }
+    }
+
+    funcs->glBindTexture(GL_TEXTURE_2D, texture);
+    if (img.depth() == 32) {
+#ifdef QT_OPENGL_ES_2
+        GLenum fmt = GL_RGBA;
+#else
+        GLenum fmt = ctx->isOpenGLES() ? GL_RGBA : GL_BGRA;
+#endif // QT_OPENGL_ES_2
+
+#if Q_BYTE_ORDER == Q_BIG_ENDIAN
+        fmt = GL_RGBA;
+#endif
+        funcs->glTexSubImage2D(GL_TEXTURE_2D, 0, tx, ty, imgWidth, imgHeight, fmt, GL_UNSIGNED_BYTE, img.constBits());
+    } else {
+        // The scanlines in image are 32-bit aligned, even for mono or 8-bit formats. This
+        // is good because it matches the default of 4 bytes for GL_UNPACK_ALIGNMENT.
+#if !defined(QT_OPENGL_ES_2)
+        const GLenum format = isCoreProfile() ? GL_RED : GL_ALPHA;
+#else
+        const GLenum format = GL_ALPHA;
+#endif
+        funcs->glTexSubImage2D(GL_TEXTURE_2D, 0, tx, ty, imgWidth, imgHeight, format, GL_UNSIGNED_BYTE, img.constBits());
+    }
+}
+
+static void load_glyph_image_region_to_texture(QOpenGLContext *ctx,
+                                               const QImage &srcImg,
+                                               int x, int y,
+                                               int w, int h,
+                                               GLuint texture,
+                                               int tx, int ty)
+{
+    Q_ASSERT(x + w <= srcImg.width() && y + h <= srcImg.height());
+
+    QImage img;
+    if (x != 0 || y != 0 || w != srcImg.width() || h != srcImg.height())
+        img = srcImg.copy(x, y, w, h);
+    else
+        img = srcImg;
+
+    load_glyph_image_to_texture(ctx, img, texture, tx, ty);
+}
+
+void QOpenGLTextureGlyphCache::resizeTextureData(int width, int height)
+{
+    QOpenGLContext *ctx = QOpenGLContext::currentContext();
+    if (ctx == nullptr) {
+        qWarning("QOpenGLTextureGlyphCache::resizeTextureData: Called with no context");
+        return;
+    }
+
+    QOpenGLFunctions *funcs = ctx->functions();
+    GLint oldFbo;
+    funcs->glGetIntegerv(GL_FRAMEBUFFER_BINDING, &oldFbo);
+
+    int oldWidth = m_textureResource->m_width;
+    int oldHeight = m_textureResource->m_height;
+
+    // Make the lower glyph texture size 16 x 16.
+    if (width < 16)
+        width = 16;
+    if (height < 16)
+        height = 16;
+
+    GLuint oldTexture = m_textureResource->m_texture;
+    createTextureData(width, height);
+
+    if (ctx->d_func()->workaround_brokenFBOReadBack) {
+        QImageTextureGlyphCache::resizeTextureData(width, height);
+        load_glyph_image_region_to_texture(ctx, image(), 0, 0, qMin(oldWidth, width), qMin(oldHeight, height),
+                                           m_textureResource->m_texture, 0, 0);
+        return;
+    }
+
+    // ### the QTextureGlyphCache API needs to be reworked to allow
+    // ### resizeTextureData to fail
+
+    funcs->glBindFramebuffer(GL_FRAMEBUFFER, m_textureResource->m_fbo);
+
+    GLuint tmp_texture;
+    funcs->glGenTextures(1, &tmp_texture);
+    funcs->glBindTexture(GL_TEXTURE_2D, tmp_texture);
+    funcs->glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, oldWidth, oldHeight, 0,
+                        GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
+    funcs->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+    funcs->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+    funcs->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+    funcs->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+    m_filterMode = Nearest;
+    funcs->glBindTexture(GL_TEXTURE_2D, 0);
+    funcs->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
+                                  GL_TEXTURE_2D, tmp_texture, 0);
+
+    funcs->glActiveTexture(GL_TEXTURE0 + QT_IMAGE_TEXTURE_UNIT);
+    funcs->glBindTexture(GL_TEXTURE_2D, oldTexture);
+
+    if (pex != nullptr)
+        pex->transferMode(BrushDrawingMode);
+
+    funcs->glDisable(GL_STENCIL_TEST);
+    funcs->glDisable(GL_DEPTH_TEST);
+    funcs->glDisable(GL_SCISSOR_TEST);
+    funcs->glDisable(GL_BLEND);
+
+    funcs->glViewport(0, 0, oldWidth, oldHeight);
+
+    QOpenGLShaderProgram *blitProgram = nullptr;
+    if (pex == nullptr) {
+        if (m_blitProgram == nullptr) {
+            m_blitProgram = new QOpenGLShaderProgram;
+            const bool isCoreProfile = ctx->format().profile() == QSurfaceFormat::CoreProfile;
+
+            {
+                QString source;
+#ifdef Q_OS_WASM
+                source.append(QLatin1String(isCoreProfile ? qopenglslUntransformedPositionVertexShader_core : qopenglslUntransformedPositionVertexShader));
+                source.append(QLatin1String(isCoreProfile ? qopenglslMainWithTexCoordsVertexShader_core : qopenglslMainWithTexCoordsVertexShader));
+#else
+                source.append(QLatin1String(isCoreProfile ? qopenglslMainWithTexCoordsVertexShader_core : qopenglslMainWithTexCoordsVertexShader));
+                source.append(QLatin1String(isCoreProfile ? qopenglslUntransformedPositionVertexShader_core : qopenglslUntransformedPositionVertexShader));
+#endif
+                m_blitProgram->addCacheableShaderFromSourceCode(QOpenGLShader::Vertex, source);
+            }
+
+            {
+                QString source;
+#ifdef Q_OS_WASM
+                source.append(QLatin1String(isCoreProfile ? qopenglslImageSrcFragmentShader_core : qopenglslImageSrcFragmentShader));
+                source.append(QLatin1String(isCoreProfile ? qopenglslMainFragmentShader_core : qopenglslMainFragmentShader));
+#else
+                source.append(QLatin1String(isCoreProfile ? qopenglslMainFragmentShader_core : qopenglslMainFragmentShader));
+                source.append(QLatin1String(isCoreProfile ? qopenglslImageSrcFragmentShader_core : qopenglslImageSrcFragmentShader));
+#endif
+                m_blitProgram->addCacheableShaderFromSourceCode(QOpenGLShader::Fragment, source);
+            }
+
+            m_blitProgram->bindAttributeLocation("vertexCoordsArray", QT_VERTEX_COORDS_ATTR);
+            m_blitProgram->bindAttributeLocation("textureCoordArray", QT_TEXTURE_COORDS_ATTR);
+
+            m_blitProgram->link();
+
+            if (m_vao.isCreated()) {
+                m_vao.bind();
+                setupVertexAttribs();
+            }
+        }
+
+        if (m_vao.isCreated())
+            m_vao.bind();
+        else
+            setupVertexAttribs();
+
+        m_blitProgram->bind();
+        blitProgram = m_blitProgram;
+
+    } else {
+        pex->uploadData(QT_VERTEX_COORDS_ATTR, m_vertexCoordinateArray, 8);
+        pex->uploadData(QT_TEXTURE_COORDS_ATTR, m_textureCoordinateArray, 8);
+
+        pex->shaderManager->useBlitProgram();
+        blitProgram = pex->shaderManager->blitProgram();
+    }
+
+    blitProgram->setUniformValue("imageTexture", QT_IMAGE_TEXTURE_UNIT);
+
+    funcs->glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
+
+    funcs->glBindTexture(GL_TEXTURE_2D, m_textureResource->m_texture);
+
+    funcs->glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, oldWidth, oldHeight);
+
+    funcs->glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
+                                     GL_RENDERBUFFER, 0);
+    funcs->glDeleteTextures(1, &tmp_texture);
+    funcs->glDeleteTextures(1, &oldTexture);
+
+    funcs->glBindFramebuffer(GL_FRAMEBUFFER, (GLuint)oldFbo);
+
+    if (pex != nullptr) {
+        funcs->glViewport(0, 0, pex->width, pex->height);
+        pex->updateClipScissorTest();
+    } else {
+        if (m_vao.isCreated()) {
+            m_vao.release();
+        } else {
+            m_blitProgram->disableAttributeArray(int(QT_VERTEX_COORDS_ATTR));
+            m_blitProgram->disableAttributeArray(int(QT_TEXTURE_COORDS_ATTR));
+        }
+    }
+}
+
+void QOpenGLTextureGlyphCache::fillTexture(const Coord &c, glyph_t glyph, QFixed subPixelPosition)
+{
+    QOpenGLContext *ctx = QOpenGLContext::currentContext();
+    if (ctx == nullptr) {
+        qWarning("QOpenGLTextureGlyphCache::fillTexture: Called with no context");
+        return;
+    }
+
+    if (ctx->d_func()->workaround_brokenFBOReadBack) {
+        QImageTextureGlyphCache::fillTexture(c, glyph, subPixelPosition);
+        load_glyph_image_region_to_texture(ctx, image(), c.x, c.y, c.w, c.h, m_textureResource->m_texture, c.x, c.y);
+        return;
+    }
+
+    QImage mask = textureMapForGlyph(glyph, subPixelPosition);
+    load_glyph_image_to_texture(ctx, mask, m_textureResource->m_texture, c.x, c.y);
+}
+
+int QOpenGLTextureGlyphCache::glyphPadding() const
+{
+    return 1;
+}
+
+int QOpenGLTextureGlyphCache::maxTextureWidth() const
+{
+    QOpenGLContext *ctx = const_cast<QOpenGLContext *>(QOpenGLContext::currentContext());
+    if (ctx == nullptr)
+        return QImageTextureGlyphCache::maxTextureWidth();
+    else
+        return ctx->d_func()->maxTextureSize();
+}
+
+int QOpenGLTextureGlyphCache::maxTextureHeight() const
+{
+    QOpenGLContext *ctx = const_cast<QOpenGLContext *>(QOpenGLContext::currentContext());
+    if (ctx == nullptr)
+        return QImageTextureGlyphCache::maxTextureHeight();
+
+    if (ctx->d_func()->workaround_brokenTexSubImage)
+        return qMin(1024, ctx->d_func()->maxTextureSize());
+    else
+        return ctx->d_func()->maxTextureSize();
+}
+
+void QOpenGLTextureGlyphCache::clear()
+{
+    if (m_textureResource)
+        m_textureResource->free();
+    m_textureResource = nullptr;
+
+    delete m_blitProgram;
+    m_blitProgram = nullptr;
+
+    m_w = 0;
+    m_h = 0;
+    m_cx = 0;
+    m_cy = 0;
+    m_currentRowHeight = 0;
+    coords.clear();
+}
+
+QT_END_NAMESPACE
diff --git a/src/opengl/qopengltextureglyphcache_p.h b/src/opengl/qopengltextureglyphcache_p.h
new file mode 100644
index 0000000000..15ecd6209b
--- /dev/null
+++ b/src/opengl/qopengltextureglyphcache_p.h
@@ -0,0 +1,181 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtOpenGL module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QOPENGLTEXTUREGLYPHCACHE_P_H
+#define QOPENGLTEXTUREGLYPHCACHE_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API. It exists purely as an
+// implementation detail. This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QtOpenGL/qtopenglglobal.h>
+#include <private/qtextureglyphcache_p.h>
+#include <private/qopenglcontext_p.h>
+#include <qopenglshaderprogram.h>
+#include <qopenglfunctions.h>
+#include <qopenglbuffer.h>
+#include <qopenglvertexarrayobject.h>
+
+// #define QT_GL_TEXTURE_GLYPH_CACHE_DEBUG
+
+QT_BEGIN_NAMESPACE
+
+class QOpenGL2PaintEngineExPrivate;
+
+class QOpenGLGlyphTexture : public QOpenGLSharedResource
+{
+public:
+    explicit QOpenGLGlyphTexture(QOpenGLContext *ctx)
+        : QOpenGLSharedResource(ctx->shareGroup())
+        , m_width(0)
+        , m_height(0)
+    {
+        if (!ctx->d_func()->workaround_brokenFBOReadBack)
+            QOpenGLFunctions(ctx).glGenFramebuffers(1, &m_fbo);
+
+#ifdef QT_GL_TEXTURE_GLYPH_CACHE_DEBUG
+        qDebug(" -> QOpenGLGlyphTexture() %p for context %p.", this, ctx);
+#endif
+    }
+
+    void freeResource(QOpenGLContext *context) override
+    {
+        QOpenGLContext *ctx = context;
+#ifdef QT_GL_TEXTURE_GLYPH_CACHE_DEBUG
+        qDebug("~QOpenGLGlyphTexture() %p for context %p.", this, ctx);
+#endif
+        if (!ctx->d_func()->workaround_brokenFBOReadBack)
+            ctx->functions()->glDeleteFramebuffers(1, &m_fbo);
+        if (m_width || m_height)
+            ctx->functions()->glDeleteTextures(1, &m_texture);
+    }
+
+    void invalidateResource() override
+    {
+        m_texture = 0;
+        m_fbo = 0;
+        m_width = 0;
+        m_height = 0;
+    }
+
+    GLuint m_texture;
+    GLuint m_fbo;
+    int m_width;
+    int m_height;
+};
+
+class Q_OPENGL_EXPORT QOpenGLTextureGlyphCache : public QImageTextureGlyphCache
+{
+public:
+    QOpenGLTextureGlyphCache(QFontEngine::GlyphFormat glyphFormat, const QTransform &matrix, const QColor &color = QColor());
+    ~QOpenGLTextureGlyphCache();
+
+    virtual void createTextureData(int width, int height) override;
+    virtual void resizeTextureData(int width, int height) override;
+    virtual void fillTexture(const Coord &c, glyph_t glyph, QFixed subPixelPosition) override;
+    virtual int glyphPadding() const override;
+    virtual int maxTextureWidth() const override;
+    virtual int maxTextureHeight() const override;
+
+    inline GLuint texture() const {
+        QOpenGLTextureGlyphCache *that = const_cast<QOpenGLTextureGlyphCache *>(this);
+        QOpenGLGlyphTexture *glyphTexture = that->m_textureResource;
+        return glyphTexture ? glyphTexture->m_texture : 0;
+    }
+
+    inline int width() const {
+        QOpenGLTextureGlyphCache *that = const_cast<QOpenGLTextureGlyphCache *>(this);
+        QOpenGLGlyphTexture *glyphTexture = that->m_textureResource;
+        return glyphTexture ? glyphTexture->m_width : 0;
+    }
+    inline int height() const {
+        QOpenGLTextureGlyphCache *that = const_cast<QOpenGLTextureGlyphCache *>(this);
+        QOpenGLGlyphTexture *glyphTexture = that->m_textureResource;
+        return glyphTexture ? glyphTexture->m_height : 0;
+    }
+
+    inline void setPaintEnginePrivate(QOpenGL2PaintEngineExPrivate *p) { pex = p; }
+
+    inline const QOpenGLContextGroup *contextGroup() const { return m_textureResource ? m_textureResource->group() : nullptr; }
+
+    inline int serialNumber() const { return m_serialNumber; }
+
+    enum FilterMode {
+        Nearest,
+        Linear
+    };
+    FilterMode filterMode() const { return m_filterMode; }
+    void setFilterMode(FilterMode m) { m_filterMode = m; }
+
+    void clear();
+
+    QOpenGL2PaintEngineExPrivate *paintEnginePrivate() const
+    {
+        return pex;
+    }
+
+private:
+    void setupVertexAttribs();
+
+    QOpenGLGlyphTexture *m_textureResource;
+
+    QOpenGL2PaintEngineExPrivate *pex;
+    QOpenGLShaderProgram *m_blitProgram;
+    FilterMode m_filterMode;
+
+    GLfloat m_vertexCoordinateArray[8];
+    GLfloat m_textureCoordinateArray[8];
+
+    int m_serialNumber;
+
+    QOpenGLBuffer m_buffer;
+    QOpenGLVertexArrayObject m_vao;
+};
+
+QT_END_NAMESPACE
+
+#endif // QOPENGLTEXTUREGLYPHCACHE_P_H
+
diff --git a/src/opengl/qopengltextureuploader.cpp b/src/opengl/qopengltextureuploader.cpp
new file mode 100644
index 0000000000..469ddc56c1
--- /dev/null
+++ b/src/opengl/qopengltextureuploader.cpp
@@ -0,0 +1,381 @@
+/****************************************************************************
+**
+** Copyright (C) 2018 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtOpenGL module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qopengltextureuploader_p.h"
+
+#include <qimage.h>
+#include <qmath.h>
+#include <qopenglfunctions.h>
+#include <private/qopenglcontext_p.h>
+#include <private/qopenglextensions_p.h>
+
+#ifndef GL_RED
+#define GL_RED                            0x1903
+#endif
+
+#ifndef GL_GREEN
+#define GL_GREEN                          0x1904
+#endif
+
+#ifndef GL_BLUE
+#define GL_BLUE                           0x1905
+#endif
+
+#ifndef GL_RGB10_A2
+#define GL_RGB10_A2                       0x8059
+#endif
+
+#ifndef GL_RGBA16
+#define GL_RGBA16                         0x805B
+#endif
+
+#ifndef GL_BGR
+#define GL_BGR 0x80E0
+#endif
+
+#ifndef GL_BGRA
+#define GL_BGRA 0x80E1
+#endif
+
+#ifndef GL_UNSIGNED_INT_8_8_8_8_REV
+#define GL_UNSIGNED_INT_8_8_8_8_REV       0x8367
+#endif
+
+#ifndef GL_UNSIGNED_INT_2_10_10_10_REV
+#define GL_UNSIGNED_INT_2_10_10_10_REV    0x8368
+#endif
+
+#ifndef GL_TEXTURE_SWIZZLE_R
+#define GL_TEXTURE_SWIZZLE_R              0x8E42
+#endif
+
+#ifndef GL_TEXTURE_SWIZZLE_G
+#define GL_TEXTURE_SWIZZLE_G              0x8E43
+#endif
+
+#ifndef GL_TEXTURE_SWIZZLE_B
+#define GL_TEXTURE_SWIZZLE_B              0x8E44
+#endif
+
+#ifndef GL_TEXTURE_SWIZZLE_A
+#define GL_TEXTURE_SWIZZLE_A              0x8E45
+#endif
+
+#ifndef GL_SRGB
+#define GL_SRGB                           0x8C40
+#endif
+#ifndef GL_SRGB_ALPHA
+#define GL_SRGB_ALPHA                     0x8C42
+#endif
+
+QT_BEGIN_NAMESPACE
+
+qsizetype QOpenGLTextureUploader::textureImage(GLenum target, const QImage &image, QOpenGLTextureUploader::BindOptions options, QSize maxSize)
+{
+    QOpenGLContext *context = QOpenGLContext::currentContext();
+    QOpenGLExtensions *funcs = static_cast<QOpenGLExtensions*>(context->functions());
+
+    QImage tx;
+    GLenum externalFormat;
+    GLenum internalFormat;
+    GLuint pixelType;
+    QImage::Format targetFormat = QImage::Format_Invalid;
+    const bool isOpenGL12orBetter = !context->isOpenGLES() && (context->format().majorVersion() >= 2 || context->format().minorVersion() >= 2);
+    const bool isOpenGLES3orBetter = context->isOpenGLES() && context->format().majorVersion() >= 3;
+    const bool sRgbBinding = (options & SRgbBindOption);
+    Q_ASSERT(isOpenGL12orBetter || context->isOpenGLES());
+    Q_ASSERT((options & (SRgbBindOption | UseRedForAlphaAndLuminanceBindOption)) != (SRgbBindOption | UseRedForAlphaAndLuminanceBindOption));
+
+    switch (image.format()) {
+    case QImage::Format_RGB32:
+    case QImage::Format_ARGB32:
+    case QImage::Format_ARGB32_Premultiplied:
+        if (isOpenGL12orBetter) {
+            externalFormat = GL_BGRA;
+            internalFormat = GL_RGBA;
+            pixelType = GL_UNSIGNED_INT_8_8_8_8_REV;
+#if Q_BYTE_ORDER == Q_LITTLE_ENDIAN
+        // Without GL_UNSIGNED_INT_8_8_8_8_REV, BGRA only matches ARGB on little endian:
+        } else if (funcs->hasOpenGLExtension(QOpenGLExtensions::BGRATextureFormat) && !sRgbBinding) {
+            // The GL_EXT_texture_format_BGRA8888 extension requires the internal format to match the external.
+            externalFormat = internalFormat = GL_BGRA;
+            pixelType = GL_UNSIGNED_BYTE;
+        } else if (context->isOpenGLES() && context->hasExtension(QByteArrayLiteral("GL_APPLE_texture_format_BGRA8888"))) {
+            // Is only allowed as an external format like OpenGL.
+            externalFormat = GL_BGRA;
+            internalFormat = GL_RGBA;
+            pixelType = GL_UNSIGNED_BYTE;
+#endif
+        } else if (funcs->hasOpenGLExtension(QOpenGLExtensions::TextureSwizzle)) {
+#if Q_BYTE_ORDER == Q_LITTLE_ENDIAN
+            funcs->glTexParameteri(target, GL_TEXTURE_SWIZZLE_R, GL_BLUE);
+            funcs->glTexParameteri(target, GL_TEXTURE_SWIZZLE_B, GL_RED);
+#else
+            funcs->glTexParameteri(target, GL_TEXTURE_SWIZZLE_R, GL_GREEN);
+            funcs->glTexParameteri(target, GL_TEXTURE_SWIZZLE_G, GL_BLUE);
+            funcs->glTexParameteri(target, GL_TEXTURE_SWIZZLE_B, GL_ALPHA);
+            funcs->glTexParameteri(target, GL_TEXTURE_SWIZZLE_A, GL_RED);
+#endif
+            externalFormat = internalFormat = GL_RGBA;
+            pixelType = GL_UNSIGNED_BYTE;
+        } else {
+            // No support for direct ARGB32 upload.
+            break;
+        }
+        targetFormat = image.format();
+        break;
+    case QImage::Format_BGR30:
+    case QImage::Format_A2BGR30_Premultiplied:
+        if (sRgbBinding) {
+            // Always needs conversion
+            break;
+        } else if (isOpenGL12orBetter || isOpenGLES3orBetter) {
+            pixelType = GL_UNSIGNED_INT_2_10_10_10_REV;
+            externalFormat = GL_RGBA;
+            internalFormat = GL_RGB10_A2;
+            targetFormat =  image.format();
+        }
+        break;
+    case QImage::Format_RGB30:
+    case QImage::Format_A2RGB30_Premultiplied:
+        if (sRgbBinding) {
+            // Always needs conversion
+            break;
+        } else if (isOpenGL12orBetter) {
+            pixelType = GL_UNSIGNED_INT_2_10_10_10_REV;
+            externalFormat = GL_BGRA;
+            internalFormat = GL_RGB10_A2;
+            targetFormat = image.format();
+        } else if (funcs->hasOpenGLExtension(QOpenGLExtensions::TextureSwizzle)) {
+            funcs->glTexParameteri(target, GL_TEXTURE_SWIZZLE_B, GL_RED);
+            funcs->glTexParameteri(target, GL_TEXTURE_SWIZZLE_R, GL_BLUE);
+            pixelType = GL_UNSIGNED_INT_2_10_10_10_REV;
+            externalFormat = GL_RGBA;
+            internalFormat = GL_RGB10_A2;
+            targetFormat = image.format();
+        }
+        break;
+    case QImage::Format_RGB444:
+    case QImage::Format_RGB555:
+    case QImage::Format_RGB16:
+        if (isOpenGL12orBetter || context->isOpenGLES()) {
+            externalFormat = internalFormat = GL_RGB;
+            pixelType = GL_UNSIGNED_SHORT_5_6_5;
+            targetFormat = QImage::Format_RGB16;
+        }
+        break;
+    case QImage::Format_RGB666:
+    case QImage::Format_RGB888:
+        externalFormat = internalFormat = GL_RGB;
+        pixelType = GL_UNSIGNED_BYTE;
+        targetFormat = QImage::Format_RGB888;
+        break;
+    case QImage::Format_BGR888:
+        if (isOpenGL12orBetter) {
+            externalFormat = GL_BGR;
+            internalFormat = GL_RGB;
+            pixelType = GL_UNSIGNED_BYTE;
+            targetFormat = QImage::Format_BGR888;
+        } else if (funcs->hasOpenGLExtension(QOpenGLExtensions::TextureSwizzle)) {
+            funcs->glTexParameteri(target, GL_TEXTURE_SWIZZLE_B, GL_RED);
+            funcs->glTexParameteri(target, GL_TEXTURE_SWIZZLE_R, GL_BLUE);
+            externalFormat = internalFormat = GL_RGB;
+            pixelType = GL_UNSIGNED_BYTE;
+            targetFormat = QImage::Format_BGR888;
+        }
+        break;
+    case QImage::Format_RGBX8888:
+    case QImage::Format_RGBA8888:
+    case QImage::Format_RGBA8888_Premultiplied:
+        externalFormat = internalFormat = GL_RGBA;
+        pixelType = GL_UNSIGNED_BYTE;
+        targetFormat = image.format();
+        break;
+    case QImage::Format_RGBX64:
+    case QImage::Format_RGBA64:
+    case QImage::Format_RGBA64_Premultiplied:
+        externalFormat = internalFormat = GL_RGBA;
+        if (isOpenGL12orBetter || (context->isOpenGLES() && context->format().majorVersion() >= 3))
+            internalFormat = GL_RGBA16;
+        pixelType = GL_UNSIGNED_SHORT;
+        targetFormat =  image.format();
+        break;
+    case QImage::Format_Indexed8:
+        if (sRgbBinding) {
+            // Always needs conversion
+            break;
+        } else if (options & UseRedForAlphaAndLuminanceBindOption) {
+            externalFormat = internalFormat = GL_RED;
+            pixelType = GL_UNSIGNED_BYTE;
+            targetFormat = image.format();
+        }
+        break;
+    case QImage::Format_Alpha8:
+        if (sRgbBinding) {
+            // Always needs conversion
+            break;
+        } else if (options & UseRedForAlphaAndLuminanceBindOption) {
+            externalFormat = internalFormat = GL_RED;
+            pixelType = GL_UNSIGNED_BYTE;
+            targetFormat = image.format();
+        } else if (context->isOpenGLES() || context->format().profile() != QSurfaceFormat::CoreProfile) {
+            externalFormat = internalFormat = GL_ALPHA;
+            pixelType = GL_UNSIGNED_BYTE;
+            targetFormat = image.format();
+        } else if (funcs->hasOpenGLExtension(QOpenGLExtensions::TextureSwizzle)) {
+            funcs->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_R, GL_ALPHA);
+            funcs->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_G, GL_ZERO);
+            funcs->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B, GL_ZERO);
+            funcs->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_A, GL_ZERO);
+            externalFormat = internalFormat = GL_RED;
+            pixelType = GL_UNSIGNED_BYTE;
+            targetFormat = image.format();
+        }
+        break;
+    case QImage::Format_Grayscale8:
+        if (sRgbBinding) {
+            // Always needs conversion
+            break;
+        } else if (options & UseRedForAlphaAndLuminanceBindOption) {
+            externalFormat = internalFormat = GL_RED;
+            pixelType = GL_UNSIGNED_BYTE;
+            targetFormat = image.format();
+        } else if (context->isOpenGLES() || context->format().profile() != QSurfaceFormat::CoreProfile) {
+            externalFormat = internalFormat = GL_LUMINANCE;
+            pixelType = GL_UNSIGNED_BYTE;
+            targetFormat = image.format();
+        } else if (funcs->hasOpenGLExtension(QOpenGLExtensions::TextureSwizzle)) {
+            funcs->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_R, GL_RED);
+            funcs->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_G, GL_RED);
+            funcs->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B, GL_RED);
+            funcs->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_A, GL_ONE);
+            externalFormat = internalFormat = GL_RED;
+            pixelType = GL_UNSIGNED_BYTE;
+            targetFormat = image.format();
+        }
+        break;
+    case QImage::Format_Grayscale16:
+        if (sRgbBinding) {
+            // Always needs conversion
+            break;
+        } else if (options & UseRedForAlphaAndLuminanceBindOption) {
+            externalFormat = internalFormat = GL_RED;
+            pixelType = GL_UNSIGNED_SHORT;
+            targetFormat = image.format();
+        } else if (context->isOpenGLES() || context->format().profile() != QSurfaceFormat::CoreProfile) {
+            externalFormat = internalFormat = GL_LUMINANCE;
+            pixelType = GL_UNSIGNED_SHORT;
+            targetFormat = image.format();
+        } else if (funcs->hasOpenGLExtension(QOpenGLExtensions::TextureSwizzle)) {
+            funcs->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_R, GL_RED);
+            funcs->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_G, GL_RED);
+            funcs->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B, GL_RED);
+            funcs->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_A, GL_ONE);
+            externalFormat = internalFormat = GL_RED;
+            pixelType = GL_UNSIGNED_SHORT;
+            targetFormat = image.format();
+        }
+        break;
+    default:
+        break;
+    }
+
+    // If no direct upload was detected above, convert to RGBA8888 and upload that
+    if (targetFormat == QImage::Format_Invalid) {
+        externalFormat = internalFormat = GL_RGBA;
+        pixelType = GL_UNSIGNED_BYTE;
+        if (!image.hasAlphaChannel())
+            targetFormat = QImage::Format_RGBX8888;
+        else
+            targetFormat = QImage::Format_RGBA8888;
+    }
+
+    if (options & PremultipliedAlphaBindOption) {
+        if (targetFormat == QImage::Format_ARGB32)
+            targetFormat = QImage::Format_ARGB32_Premultiplied;
+        else if (targetFormat == QImage::Format_RGBA8888)
+            targetFormat = QImage::Format_RGBA8888_Premultiplied;
+        else if (targetFormat == QImage::Format_RGBA64)
+            targetFormat = QImage::Format_RGBA64_Premultiplied;
+    } else {
+        if (targetFormat == QImage::Format_ARGB32_Premultiplied)
+            targetFormat = QImage::Format_ARGB32;
+        else if (targetFormat == QImage::Format_RGBA8888_Premultiplied)
+            targetFormat = QImage::Format_RGBA8888;
+        else if (targetFormat == QImage::Format_RGBA64_Premultiplied)
+            targetFormat = QImage::Format_RGBA64;
+    }
+
+    if (sRgbBinding) {
+        Q_ASSERT(internalFormat == GL_RGBA || internalFormat == GL_RGB);
+        if (image.hasAlphaChannel())
+            internalFormat = GL_SRGB_ALPHA;
+        else
+            internalFormat = GL_SRGB;
+    }
+
+    if (image.format() != targetFormat)
+        tx = image.convertToFormat(targetFormat);
+    else
+        tx = image;
+
+    QSize newSize = tx.size();
+    if (!maxSize.isEmpty())
+        newSize = newSize.boundedTo(maxSize);
+    if (options & PowerOfTwoBindOption) {
+        newSize.setWidth(qNextPowerOfTwo(newSize.width() - 1));
+        newSize.setHeight(qNextPowerOfTwo(newSize.height() - 1));
+    }
+
+    if (newSize != tx.size())
+        tx = tx.scaled(newSize, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
+
+    // Handle cases where the QImage is actually a sub image of its image data:
+    qsizetype naturalBpl = ((qsizetype(tx.width()) * tx.depth() + 31) >> 5) << 2;
+    if (tx.bytesPerLine() != naturalBpl)
+        tx = tx.copy(tx.rect());
+
+    funcs->glTexImage2D(target, 0, internalFormat, tx.width(), tx.height(), 0, externalFormat, pixelType, tx.constBits());
+
+    qsizetype cost = qint64(tx.width()) * tx.height() * tx.depth() / 8;
+
+    return cost;
+}
+
+QT_END_NAMESPACE
diff --git a/src/opengl/qopengltextureuploader_p.h b/src/opengl/qopengltextureuploader_p.h
new file mode 100644
index 0000000000..cea6d97658
--- /dev/null
+++ b/src/opengl/qopengltextureuploader_p.h
@@ -0,0 +1,84 @@
+/****************************************************************************
+**
+** Copyright (C) 2018 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtOpenGL module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#ifndef QOPENGLTEXTUREUPLOADER_P_H
+#define QOPENGLTEXTUREUPLOADER_P_H
+
+#include <QtCore/qsize.h>
+#include <QtOpenGL/qtopenglglobal.h>
+#include <QtGui/private/qopenglcontext_p.h>
+
+QT_BEGIN_NAMESPACE
+
+class QImage;
+
+class Q_OPENGL_EXPORT QOpenGLTextureUploader
+{
+public:
+    enum BindOption {
+        NoBindOption                            = 0x0000,
+        PremultipliedAlphaBindOption            = 0x0001,
+        UseRedForAlphaAndLuminanceBindOption    = 0x0002,
+        SRgbBindOption                          = 0x0004,
+        PowerOfTwoBindOption                    = 0x0008
+    };
+    Q_DECLARE_FLAGS(BindOptions, BindOption)
+    Q_FLAGS(BindOptions)
+
+    static qsizetype textureImage(GLenum target, const QImage &image, BindOptions options, QSize maxSize = QSize());
+
+};
+
+Q_DECLARE_OPERATORS_FOR_FLAGS(QOpenGLTextureUploader::BindOptions)
+
+QT_END_NAMESPACE
+
+#endif
+
diff --git a/src/opengl/qopenglwidget.cpp b/src/opengl/qopenglwidget.cpp
index a6c63ae034..91e9fd545d 100644
--- a/src/opengl/qopenglwidget.cpp
+++ b/src/opengl/qopenglwidget.cpp
@@ -45,14 +45,16 @@
 #include <QtGui/QWindow>
 #include <QtGui/QGuiApplication>
 #include <QtGui/QScreen>
-#include <QtGui/QOpenGLPaintDevice>
 #include <QtGui/qpa/qplatformwindow.h>
 #include <QtGui/qpa/qplatformintegration.h>
+#include <QtOpenGL/QOpenGLPaintDevice>
+
 #include <QtGui/private/qguiapplication_p.h>
 #include <QtGui/private/qopenglextensions_p.h>
 #include <QtGui/private/qfont_p.h>
-#include <QtGui/private/qopenglpaintdevice_p.h>
 #include <QtGui/private/qopenglcontext_p.h>
+#include <QtOpenGL/private/qopenglpaintdevice_p.h>
+
 #include <QtWidgets/private/qwidget_p.h>
 
 QT_BEGIN_NAMESPACE
diff --git a/src/opengl/qopenglwindow.cpp b/src/opengl/qopenglwindow.cpp
index 8cdf134bfd..9328d9b46a 100644
--- a/src/opengl/qopenglwindow.cpp
+++ b/src/opengl/qopenglwindow.cpp
@@ -39,7 +39,6 @@
 
 #include "qopenglwindow.h"
 #include <QtGui/QOpenGLFramebufferObject>
-#include <QtGui/QOpenGLPaintDevice>
 #include <QtGui/QOpenGLFunctions>
 #include <QtGui/QOpenGLTextureBlitter>
 #include <QtGui/private/qpaintdevicewindow_p.h>
@@ -47,6 +46,7 @@
 #include <QtGui/private/qopenglcontext_p.h>
 #include <QtGui/QMatrix4x4>
 #include <QtGui/QOffscreenSurface>
+#include <QtOpenGL/QOpenGLPaintDevice>
 
 QT_BEGIN_NAMESPACE